Изменить размер раздела Windows в Windows, и получил перезагрузку командной строки спасения вместо Grub при перезагрузке

Как опубликовал в другом месте , переустановка GRUB2 в основную загрузочную запись имеет тенденцию решать подобные проблемы. Вы можете сделать это, используя любой из этих методов . Однако вы сказали, что безуспешно пытались изменить размер системного раздела Ubuntu. Поэтому, прежде чем приступить к записи на диск, вы можете убедиться, что эта операция не привела к потере данных. Вы можете сделать это, загрузившись с живого CD / DVD или USB-устройства флэш-памяти Ubuntu и проверив доступ к своим файлам. Если вы больше не можете найти свой раздел Ubuntu, и в вашей системе Ubuntu были важные документы, резервные копии которых не были текущими, то вы можете следовать рекомендациям, приведенным в этого руководства - , попытаться восстановить ваш данные. (Как правило, при динамическом изменении размеров разделов, особенно с помощью сторонних инструментов, рекомендуется обеспечить актуальность всех резервных копий документов и других важных файлов.)

Если Вы знаете, что форма является прямоугольником в плоскости, можно значительно далее ограничить проблему. Вы, конечно, не можете выяснить, "какая" плоскость, таким образом, можно выбрать это, это лежит на плоскости, где z=0 и один из углов в x=y=0, и края параллельны x/y оси.

Точки в 3-м поэтому {0,0,0}, {w, 0,0}, {w, h, 0}, и {0, h, 0}. Я вполне уверен, абсолютный размер не будет найден, поэтому только отношение w/h является releavant, таким образом, это - одно неизвестное.

Относительно этой плоскости камера должна быть в какой-то момент cx, cy, cz в пространстве, должен указывать в направлении nx, ny, nz (вектор длины одна, таким образом, один из них избыточен), и имейте focal_length/image_width фактор w. Эти числа превращаются 3x3 матрица проекции.

Это дает в общей сложности 7 неизвестных: w/h, cx, cy, cz, nx, ny и w.

У Вас есть в общей сложности 8 knowns: 4 x+y пары.

Таким образом, это может быть решено.

Следующий шаг должен использовать Matlab или Mathmatica.

Следовать подходу Rons: можно найти z-значения, если Вы знаете, как Вы повернули свой прямоугольник.

Прием должен найти проективную матрицу, которая сделала проекцию. К счастью, это возможно и даже дешево, чтобы сделать. Соответствующая математика может быть найдена в газете "Проективные Отображения для Изображения, Деформирующегося" Paul Heckbert.

http://pages.cs.wisc.edu/~dyer/cs766/readings/heckbert-proj.pdf

Таким образом, можно восстановить однородную часть каждой вершины назад, которая была потеряна во время проекции.

Теперь Вас все еще оставляют с четырьмя строками вместо точек (как Ron объяснил). Так как Вы знаете размер своего исходного прямоугольника однако, ничто не потеряно. Можно теперь включить данные из метода Ron и из 2D подхода в решатель линейного уравнения и решить для z. Вы получаете точные z-значения каждой вершины тот путь.

Примечание: Это просто работает потому что:

1. Исходная форма была прямоугольником
2. Вы знаете точный размер прямоугольника в 3D пространстве.

Это - особый случай действительно.

Надежда это помогает, Nils

Благодаря @Vegard для превосходного ответа. Я очистил код немного:

import pandas as pd
import numpy as np

class Point2:
    def __init__(self,x,y):
        self.x = x
        self.y = y

class Point3:
    def __init__(self,x,y,z):
        self.x = x
        self.y = y
        self.z = z

# Known 2D coordinates of our rectangle
i0 = Point2(318, 247)
i1 = Point2(326, 312)
i2 = Point2(418, 241)
i3 = Point2(452, 303)

# 3D coordinates corresponding to i0, i1, i2, i3
r0 = Point3(0, 0, 0)
r1 = Point3(0, 0, 1)
r2 = Point3(1, 0, 0)
r3 = Point3(1, 0, 1)

mat = [
    [1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1],
]

def project(p, mat):
    #print mat
    x = mat[0][0] * p.x + mat[0][1] * p.y + mat[0][2] * p.z + mat[0][3] * 1
    y = mat[1][0] * p.x + mat[1][1] * p.y + mat[1][2] * p.z + mat[1][3] * 1
    w = mat[3][0] * p.x + mat[3][1] * p.y + mat[3][2] * p.z + mat[3][3] * 1
    return Point2(720 * (x / w + 1) / 2., 576 - 576 * (y / w + 1) / 2.)

# The squared distance between two points a and b
def norm2(a, b):
    dx = b.x - a.x
    dy = b.y - a.y
    return dx * dx + dy * dy

def evaluate(mat): 
    c0 = project(r0, mat)
    c1 = project(r1, mat)
    c2 = project(r2, mat)
    c3 = project(r3, mat)
    return norm2(i0, c0) + norm2(i1, c1) + norm2(i2, c2) + norm2(i3, c3)    

def perturb(mat, amount):
    from copy import deepcopy
    from random import randrange, uniform
    mat2 = deepcopy(mat)
    mat2[randrange(4)][randrange(4)] += uniform(-amount, amount)
    return mat2

def approximate(mat, amount, n=1000):
    est = evaluate(mat)
    for i in xrange(n):
        mat2 = perturb(mat, amount)
        est2 = evaluate(mat2)
        if est2 < est:
            mat = mat2
            est = est2

    return mat, est

for i in xrange(1000):
    mat,est = approximate(mat, 1)
    print mat
    print est

приблизительный вызов с.1 не работал на меня, таким образом, я вынул его. Я выполнил его некоторое время также, и в последний раз я проверил, что это были по телефону

[[0.7576315397559887, 0, 0.11439449272592839, -0.314856490473439], 
[0.06440497208710227, 1, -0.5607502645413118, 0.38338196981556827], 
[0, 0, 1, 0], 
[0.05421620936883742, 0, -0.5673977598434641, 2.693116299312736]]

с ошибкой приблизительно 0,02.

Да, работы Монте-Карло, но я нашел лучшее решение для этой проблемы. Этот код работает отлично (и использует OpenCV):

Cv2.CalibrateCamera(new List<List<Point3f>>() { points3d }, new List<List<Point2f>>() { points2d }, new Size(height, width), cameraMatrix, distCoefs, out rvecs, out tvecs, CalibrationFlags.ZeroTangentDist | CalibrationFlags.FixK1 | CalibrationFlags.FixK2 | CalibrationFlags.FixK3);

Эта функция берет известные 3-и и 2-е точки, размер экрана и возвращает вращение (rvecs [0]), перевод (tvecs [0]) и матрица intrinsics значений камеры. Это - все, в чем Вы нуждаетесь.

Хорошо, я приехал, сюда ища ответ и не нашел что-то простым и простым, таким образом, я шел вперед и сделал немых, но эффективный (и относительно простой) вещь: оптимизация Монте-Карло.

Очень проще говоря, алгоритм следующие: Случайным образом встревожьте свою матрицу проекции, пока она не спроектирует Ваши известные 3D координаты к Вашим известным 2D координатам.

Вот является тихая фотография от Thomas Танковым двигателем:

Скажем, мы используем GIMP для нахождения 2D координат того, что мы думаем, квадрат на наземной плоскости (является ли это действительно квадратом, зависит от суждения о глубине):

я понимаю четыре мысли в 2D изображении: (318, 247), (326, 312), (418, 241), и (452, 303).

Условно, мы говорим, что эти точки должны соответствовать 3D точкам: (0, 0, 0), (0, 0, 1), (1, 0, 0), и (1, 0, 1). Другими словами, квадрат единицы в y=0 плоскости.

Проектирование каждой из этих 3D координат в 2D сделано путем умножения 4D вектор [x, y, z, 1] с 4x4 матрица проекции, затем деления компонентов X и Y z для фактического получения перспективного исправления. Это более или менее, что делает gluProject () , кроме [1 119] также принимает текущую область просмотра во внимание и берет отдельную modelview матрицу во внимание (мы можем просто предположить, что modelview матрица является единичной матрицей). Очень удобно посмотреть gluProject() документация, потому что я на самом деле хочу решение, которое работает на OpenGL, но остерегайтесь этого, документация пропускает подразделение z в формуле.

Помнят, алгоритм должен запуститься с некоторой матрицы проекции и случайным образом встревожить ее, пока она не дает проекцию, которую мы хотим. Таким образом, то, что мы собираемся сделать, является проектом каждая из четырех 3D точек, и посмотрите, как близко мы добираемся до 2D точек, которые мы хотели. Если наши случайные возмущения заставляют спроектированные 2D точки становиться ближе к тем, мы отметили выше, то мы сохраняем ту матрицу как улучшение по сравнению с нашей начальной буквой (или предыдущий) предположение.

Позволяют нам определить наши точки:

# Known 2D coordinates of our rectangle
i0 = Point2(318, 247)
i1 = Point2(326, 312)
i2 = Point2(418, 241)
i3 = Point2(452, 303)

# 3D coordinates corresponding to i0, i1, i2, i3
r0 = Point3(0, 0, 0)
r1 = Point3(0, 0, 1)
r2 = Point3(1, 0, 0)
r3 = Point3(1, 0, 1)

Мы должны запустить с некоторой матрицы, единичная матрица кажется естественным выбором:

mat = [
    [1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1],
]

Мы должны на самом деле реализовать проекцию (который является в основном умножением матриц):

def project(p, mat):
    x = mat[0][0] * p.x + mat[0][1] * p.y + mat[0][2] * p.z + mat[0][3] * 1
    y = mat[1][0] * p.x + mat[1][1] * p.y + mat[1][2] * p.z + mat[1][3] * 1
    w = mat[3][0] * p.x + mat[3][1] * p.y + mat[3][2] * p.z + mat[3][3] * 1
    return Point(720 * (x / w + 1) / 2., 576 - 576 * (y / w + 1) / 2.)

Это в основном, что gluProject() делает, 720 и 576 ширина и высота изображения, соответственно (т.е. область просмотра), и мы вычитаем от 576 для значения того, что мы считали координаты y от вершины, в то время как OpenGL обычно считает их от нижней части. Вы заметите, что мы не вычисляем z, поэтому нам действительно не нужен он здесь (хотя могло быть удобно гарантировать, что он находится в пределах диапазона, который OpenGL использует для буфера глубины).

Теперь нам нужна функция для оценки, как близко мы к правильному решению. Значение, возвращенное этой функцией, - то, что мы будем использовать для проверки, лучше ли одна матрица, чем другой. Я принял решение пойти суммой квадратов расстояний, т.е.:

# The squared distance between two points a and b
def norm2(a, b):
    dx = b.x - a.x
    dy = b.y - a.y
    return dx * dx + dy * dy

def evaluate(mat): 
    c0 = project(r0, mat)
    c1 = project(r1, mat)
    c2 = project(r2, mat)
    c3 = project(r3, mat)
    return norm2(i0, c0) + norm2(i1, c1) + norm2(i2, c2) + norm2(i3, c3)

Для беспокойства матрицы мы просто выбираем элемент для беспокойства случайной суммой в некотором диапазоне:

def perturb(amount):
    from copy import deepcopy
    from random import randrange, uniform
    mat2 = deepcopy(mat)
    mat2[randrange(4)][randrange(4)] += uniform(-amount, amount)

(Стоит отметить, что наш project() функция на самом деле не использует mat[2] вообще, так как мы не вычисляем z, и так как все наши координаты y 0 mat[*][1], значения не важны также. Мы могли использовать этот факт и никогда не пытаться встревожить те значения, которые дадут маленькое ускорение, но это оставляют как осуществление...)

Для удобства, давайте добавим функцию, которая делает объем приближения путем вызова perturb() много раз на том, что является лучшей матрицей, которую мы нашли до сих пор:

def approximate(mat, amount, n=100000):
    est = evaluate(mat)

    for i in xrange(n):
        mat2 = perturb(mat, amount)
        est2 = evaluate(mat2)
        if est2 < est:
            mat = mat2
            est = est2

    return mat, est

Теперь все это оставляют сделать, должен выполнить его...:

for i in xrange(100):
    mat = approximate(mat, 1)
    mat = approximate(mat, .1)

я нахожу, что это уже дает довольно точный ответ. После выполнения некоторое время, матрица, которую я нашел, была:

[
    [1.0836000765696232,  0,  0.16272110011060575, -0.44811064935115597],
    [0.09339193527789781, 1, -0.7990570384334473,   0.539087345090207  ],
    [0,                   0,  1,                    0                  ],
    [0.06700844759602216, 0, -0.8333379578853196,   3.875290562060915  ],
]

с ошибкой приблизительно [1 126]. (Заметьте, как элементы, которые, как мы сказали, не использовались в вычислении, не были на самом деле изменены от нашей начальной матрицы; поэтому изменение этих записей не изменило бы результат оценки и таким образом, изменение никогда не нести вперед.)

Мы можем передать матрицу в OpenGL с помощью [1 127] (но не забыть транспонировать его сначала и не забывать загружать modelview матрицу единичной матрицей):

def transpose(m):
    return [
        [m[0][0], m[1][0], m[2][0], m[3][0]],
        [m[0][1], m[1][1], m[2][1], m[3][1]],
        [m[0][2], m[1][2], m[2][2], m[3][2]],
        [m[0][3], m[1][3], m[2][3], m[3][3]],
    ]

glLoadMatrixf(transpose(mat))

Теперь мы можем, например, перевести вдоль оси z для получения различных положений вдоль дорожек:

glTranslate(0, 0, frame)
frame = frame + 1

glBegin(GL_QUADS)
glVertex3f(0, 0, 0)
glVertex3f(0, 0, 1)
glVertex3f(1, 0, 1)
glVertex3f(1, 0, 0)
glEnd()

Наверняка это не очень изящно с математической точки зрения; Вы не получаете закрытое уравнение формы, что можно просто включить числа и получить прямое (и точный) ответ. ОДНАКО это действительно позволяет Вам добавлять дополнительные ограничения, не имея необходимость волноваться об усложнении Ваших уравнений; например, если бы мы хотели включить высоту также, то мы могли бы использовать тот угол дома и сказать (в нашей функции оценки), что расстояние от земли до крыши должно быть таким-сяким, и выполнить алгоритм снова. Таким образом да, это - своего рода грубая сила, но работы, и работают хорошо.

D. DeMenthon разработал алгоритм для вычислений поза из объекта (его положение и ориентация в пространстве) от характерных точек в 2D изображении при знании модели объекта - это - точная проблема :

Мы описываем метод для нахождения позы объекта из единственного изображения. Мы предполагаем, что можем обнаружить и соответствовать в изображении четырем или больше некомпланарным характерным точкам объекта, и что мы знаем их относительную геометрию на объекте.

алгоритм известен, поскольку Устанавливают , и описан в нем классическая статья "Model-Based Object Pose in 25 Lines of Code" (доступный на ее веб-сайт , разделите 4).

Прямая ссылка на статью: http://www.cfar.umd.edu/~daniel/daniel_papersfordownload/Pose25Lines.pdf реализация OpenCV: http://opencv.willowgarage.com/wiki/Posit

идея к повторному приближению перспективной проекции масштабируемая ортогональная проекция до схождения к точной позе.

Это - Классическая проблема для основанной на маркере Дополненной реальности.

у Вас есть квадратный маркер (двухмерный штрихкод), и Вы хотите найти его Позу (перевод & вращение относительно камеры), после нахождения четырех краев маркера. Изображение обзора

я не знаю о последних вкладах в поле, но по крайней мере в какой-то степени (2009), RPP, как предполагалось, превосходил по характеристикам, УСТАНАВЛИВАЮТ, который упомянут выше (и действительно классический подход для этого), см. ссылки, они также обеспечивают источник.

• http://www.emt.tugraz.at/~vmg/schweighofer

• http://www.emt.tugraz.at/publications/EMT_TR/TR-EMT-2005-01.pdf

• http://www.emt.tugraz.at/system/files/rpp_MATLAB_ref_implementation.tar.gz

(PS - я знаю, что это - немного старая тема, но так или иначе, сообщение могло бы быть полезно кому-то)