Видеть невидимое

Траверс бинарного BVH-дерева

2012-02-17T09:25:00.000+04:00

...или как бродить по бинарному BVH-дереву. Написано коряво и неполно, но работает.

// hitTris - в результате будет содержать все треугольники сцены
// которые пересекает (true) заданный луч, false - если ничего не пересекает
private bool TraverseBvh(
    BvhNode currentNode,
    Ray ray,
    int depth,
    List<Triangle> hitTris
 )
{
    // можно оптимизировать, если обрабатывать границы отсечения
    // (там, где числа -100000.0f)
    if (!Utils.RayBoxIntersect(
            ray,
            currentNode.AABBox,
            -100000.0f,
            100000.0f))
    {
        return false;
    }
    else
    {
        if (currentNode.IsLeaf)
        {
            maxLeafTris = Math.Max(maxLeafTris, currentNode.TriangleList.Count);
            if (currentNode.TriangleList != null)
            {
                hitTris.AddRange(currentNode.TriangleList);
            }
            return true;
        }
        else
        {
            bool isHit =
                TraverseBvh(currentNode.LeftNode, ray, depth + 1, hitTris);
            isHit |=
                TraverseBvh(currentNode.RightNode, ray, depth + 1, hitTris);

            return isHit;
        }
    }
}

После траверса мы получим список треугольников, пересекаемые лучом, а точнее, список треугольников, чьи AABB пересекает луч, т. е. сам треугольник может быть и не пересекается и луч проходит где-то совсем рядом. Нужно провести точное измерение с помощью RayTriangleIntersect.

// пересекает ли вообще хоть что-то?
TraverseBvh(bvhRootNode, ray, 0, listTri);

если пересекает
{
    для каждого треугольника в полученном списке
    проверяем пересечение с лучом
    {
        Utils.RayTriangleIntersect(tri, ray, ref oDot);
        // если пересекает, то получаем точку пересечения
    }
}

...но и после такой проверки мы можем получить несколько треугольников. Что с ними делать и как выделить нужный нам - оставляю на домашнюю работу... ну или просто выбрать ближайший к Ray.Origin по направлению Ray.Direction.

Построение бинарного BVH-дерева

2012-02-17T09:13:00.001+04:00

Описание "что это? и зачем это?" можно прочитать в посте Стрельба по кубикам.

// рекурсивное разбиение пространства сцены
public BvhNode GenerateBvhTree(
    AABB currentBBox,
    List<Triangle> plist,
    int depth)
{
    BvhNode node = new BvhNode();
    node.AABBox = currentBBox;

    if (plist.Count < 2)
    {
        node.TriangleList = plist;
        return node;
    }

    List<Triangle>[] plists = new List<Triangle>[3]{
        new List<Triangle>(plist),
        new List<Triangle>(plist),
        new List<Triangle>(plist)
        };
    SplitData splitData = FindObjectSplit(node.AABBox, plists);
    if (splitData.isDivideNext)
    {
        node.LeftNode = GenerateBvhTree(
            splitData.leftBound,
            plists[splitData.axis].GetRange(
                0,
                splitData.trisLeft),
            depth + 1);
        node.RightNode = GenerateBvhTree(
            splitData.rightBound,
            plists[splitData.axis].GetRange(
                splitData.trisLeft,
                splitData.trisRight),
            depth + 1);
    }
    else
    {
        node.TriangleList = plist;
    }

    return node;
}

// сортировка по максимальному AABB вдоль требуемой оси
private List<Triangle> SortList(List<Triangle> tris, int dim)
{
    tris.Sort(
        delegate(Triangle t1, Triangle t2)
        {
            if (t1.AABBox.BoundsMax[dim] < t2.AABBox.BoundsMax[dim])
                return -1;
            else
                if (t1.AABBox.BoundsMax[dim] > t2.AABBox.BoundsMax[dim])
                    return 1;
            
            return 0;
        });
    return tris;
}

private struct SplitData
{
    public float SAH;           // вес
    public int axis;            // ось разбивки
    public int trisLeft;        // кол-во треугольников в левой части
    public int trisRight;       // кол-во треугольников в правой части
    public AABB leftBound;      // AABB левой части
    public AABB rightBound;     // AABB правой части
    public bool isDivideNext;   // нужно ли разбивать далее
}

// поиск разбиения
private SplitData FindObjectSplit(
    AABB a_box,
    List<Triangle>[] a_plists)
{
    SplitData splitData = new SplitData();
    float a_boxSAH = a_box.SurfaceArea * a_plists[0].Count;
    splitData.SAH = a_boxSAH;
    splitData.isDivideNext = false;
    splitData.axis = -1;

    AABB[] rightBounds = new AABB[a_plists[0].Count];
    for (int axis = 0; axis < 3; axis++)
    {
        // sort data according to axis
        List<Triangle> plist = a_plists[axis];
        SortList(plist, axis);

        // Sweep right to left and determine bounds.
        AABB rightBounds1 = new AABB();
        int c = plist.Count - 1;
        for (int i = c; i > 0; i--)
        {
            rightBounds1.Include(plist[i].AABBox);
            rightBounds[i - 1] = new AABB(rightBounds1);
        }

        // Sweep left to right and select lowest SAH.
        AABB leftBounds = new AABB();
        for (int i = 1; i < plist.Count; i++)
        {
            leftBounds.Include(plist[i - 1].AABBox);
            float sah = leftBounds.SurfaceArea * i +
                rightBounds[i - 1].SurfaceArea * (plist.Count - i);
            if (sah < splitData.SAH)
            {
                splitData.SAH = sah;
                splitData.axis = axis;
                splitData.trisLeft = i;
                splitData.trisRight = plist.Count - i;
                splitData.leftBound = new AABB(leftBounds);
                splitData.rightBound = new AABB(rightBounds[i - 1]);
            }
        }
    }

    splitData.isDivideNext =
        (splitData.axis != -1) && (splitData.SAH < a_boxSAH);
                
    return splitData;
}

Литература: Early Split Clipping for Bounding Volume Hierarchies. Manfred Ernst. Gunthe Greiner. Lehrstuhl fur Graphische Datenverarbeitung Universit at Erlangen-Nurnberg, Germany

Нормаль в точке пересечения луча и треугольника

2012-02-16T12:42:00.001+04:00

Интерполяция нормалей в точке пересечения луча и треугольника будем считать с помощью предварительно расчитанных коэффициентов (см. Пересечение луча и треугольника, метод Precalculate)

BC = B - C
AC = A - C
Denominator = 1.0f / Vector3f.Cross(AC, BC).Length

public Vector3f NormalForDot(Vector3f dot)
{
    float u = Vector3f.Cross(dot - _c, _bc).Length * _denominator;
    float v = Vector3f.Cross(_ac, dot - _c).Length * _denominator;
    float w = 1.0f - u - v;

    Vector3f n = new Vector3f(
        nA.X * u + nB.X * v + nC.X * w,
        nA.Y * u + nB.Y * v + nC.Y * w,
        nA.Z * u + nB.Z * v + nC.Z * w
        );

    return n;
}

Пересечение луча и AABB

2012-02-16T12:35:00.000+04:00

AABB - Axis Aligned Bounding Box (выровненный по осям описывающий параллелепипед, вписываем объект в коробку). Т. е. будем искать пересечение луча и куба/коробки/параллелепипеда.

Тривиальный код AABB находится в классе AABB. t0 и t1 - позволяют отсекать большие куски пространства и обязательно пригодятся в дальнейшем для оптимизации.

public static bool RayBoxIntersect(Ray ray, AABB bbox, float t0, float t1)
{
    float tmin, tmax, tymin, tymax, tzmin, tzmax;

    float divx = 1.0f / ray.Direction.X;
    if (divx >= 0.0f)
    {
        tmin = (bbox.BoundsMin.X - ray.Origin.X) * divx;
        tmax = (bbox.BoundsMax.X - ray.Origin.X) * divx;
    }
    else
    {
        tmin = (bbox.BoundsMax.X - ray.Origin.X) * divx;
        tmax = (bbox.BoundsMin.X - ray.Origin.X) * divx;
    }

    float divy = 1.0f / ray.Direction.Y;
    if (divy >= 0.0f)
    {
        tymin = (bbox.BoundsMin.Y - ray.Origin.Y) * divy;
        tymax = (bbox.BoundsMax.Y - ray.Origin.Y) * divy;
    }
    else
    {
        tymin = (bbox.BoundsMax.Y - ray.Origin.Y) * divy;
        tymax = (bbox.BoundsMin.Y - ray.Origin.Y) * divy;
    }

    if ((tmin > tymax) || (tymin > tmax))
    {
        return false;
    }

    if (tymin > tmin)
    {
        tmin = tymin;
    }

    if (tymax < tmax)
    {
        tmax = tymax;
    }

    float divz = 1.0f / ray.Direction.Z;
    if (divz >= 0.0f)
    {
        tzmin = (bbox.BoundsMin.Z - ray.Origin.Z) * divz;
        tzmax = (bbox.BoundsMax.Z - ray.Origin.Z) * divz;
    }
    else
    {
        tzmin = (bbox.BoundsMax.Z - ray.Origin.Z) * divz;
        tzmax = (bbox.BoundsMin.Z - ray.Origin.Z) * divz;
    }

    if ((tmin > tzmax) || (tzmin > tmax))
    {
        return false;
    }

    if (tzmin > tmin)
    {
        tmin = tzmin;
    }

    if (tzmax < tmax)
    {
        tmax = tzmax;
    }

    return ((tmin < t1) && (tmax > t0));
}

Код доступен в классе Utils.

Литература:
An Efficient and Robust Ray–Box Intersection Algorithm. Amy Williams, Steve Barrus, R. Keith Morley, Peter Shirley. University of Utah

Пересечение луча и треугольника

2012-02-16T12:22:00.000+04:00

Треугольник задан тремя вершинами (используем три вектора): A, B, C. Для интерполяции (сглаживания поверхности треугольника) в каждой вершине заданы нормали: nA, nB, nC. Нормали можно посчитать, но я их брал из Blender, нажимая кнопку Smooth (так проще). Для всего треугольника задана нормаль N (она рассчитывается по трем вершинам).

Чтобы работало быстро делаем предварительные вычисления:

private void Precalculate()
{
    _ac = new Vector3f(_a - _c);
    _bc = new Vector3f(_b - _c);
    _cross_acbc = Vector3f.Cross(_ac, _bc);
    _denominator = 1.0f / _cross_acbc.Length;
    _n = Vector3f.Normalize(_cross_acbc);
// ...

Нам понадобится маленькая величина, для большей точности и чтобы случайно не разделить на ноль: EPSILON = 0.000001f. Теперь все готово для вычисления пересечения
Дальше →

Камера для рейтрейсинга

2012-02-16T10:21:00.000+04:00

Основные параметры камеры:
- Местоположение - Position
- Точка, куда камера смотрит - Target
- Угол обзора - FOV

Часть коэффициентов математики камеры, можно посчитать заранее. Это делает метод Precalculate.

private void Precalculate()
{
    // переводим экранное разрешение (в пикселах) в разрешение сцены
    Vector3f v0 = _target - _position;
    float a = v0.Length;

    float q = _fov / 2.0f;
    float b = Math.Abs(a / (float)Math.Tan(q));

    // предрасчет коэффициентов
    _Lu = b * 2.0f;
    _Lv = _Lu;
    Vector3f E_A = _position - _target;
    Vector3f w = E_A / E_A.Length;
    Vector3f UpxE_A = _up.Cross(E_A);
    _u = UpxE_A / UpxE_A.Length;
    _v = Vector3f.Cross(w, _u);
}

При трассировке каждого пиксела картинки, нам нужно вычислить направление трассируемого луча (Ray.Direction). У нас есть точка откуда мы смотрим на сцену (Position, она же положение луча Ray.Origin) и координаты пиксела на экране через который мы выстреливаем луч. Теперь нужно рассчитать направление луча (Ray.Direction) т.е. увязать основные параметры камеры с координатами пиксела на экране. Это делает метод Direction на основе расчитанных ранее коэффициентов (Precalculate).

// строим направление луча выстреливаемого через пиксел (x_px, y_px)
// строим направление луча выстреливаемого через пиксел (x_px, y_px)
// на основе параметров камеры
public Vector3f Direction(float x_px, float y_px)
{
    float cu = ((2.0f * x_px + 1.0f) / _widthPx2 - 0.5f) * _Lu;
    float cv = ((2.0f * y_px + 1.0f) / _heightPx2 - 0.5f) * _Lv;
    Vector3f Pij = _target - cu * _u - cv * _v;
    Vector3f Pij_E = Pij - _position;
    Vector3f dir = Pij_E / Pij_E.Length;
    dir.Normalize();

    return dir;
}

При расчете отражений мы используем уже не координаты камеры, а координаты точки пересечения луча и треугольника, т. е. Ray.Origin = точка пересечения предыдущего луча и треугольника, Ray.Direction = угол падения=углу отражения.

Класс Camera содержит некоторые неточности, но в общем работает.

Литература: Vector Algebra for Ray Tracing, Dr. Thomas W. Sederberg, 14 February 2005

Как работает рейтрейсинг?

2012-02-16T09:57:00.000+04:00

for (y = 0; y < высота картинки в пикселах; y = y + 1)
{
    for (x = 0; y < ширина картинки в пикселах; x = x + 1)
    {
        // задаем параметры луча трассировки        
        //местоположение камеры/глаза
        Ray.Origin = Camera.Origin
        // преобразовать координаты пиксела (x, y) в вектор направления взгляда
        Ray.Direction = Camera.Direction(x, y)
        
        // непосредственно трассировка луча - получение цвета пиксела (x, y)
        RGB color =
            Raytrace
            (
                Ray,
                текущий уровень рекурсии = 0,
                количество отражений/переотражений, например = 3
            )

        // выводим расчитанный пиксел на экран
        ScreenPixel[x, y] = color;
    }
}

Класс Vector3f - координаты вектора и операции с векторами: сложение, вычитание, и др.
Класс Camera и его метод Direction - позднее.
Луч трассировки задается тривиальным классом Ray.

Raytrace - основа всего рейтрейсера. В общем виде, он ищет с каким треугольником сцены столкнулся луч и возвращает цвет треугольника. Если есть отражения/переотражения, то метод вызывает сам себя (рекурсия) и далее ищет цвет отражения.

Гроздь винограда

2012-02-15T16:23:00.002+04:00

Сделал небольшую оптимизацию кода, нашел места где нужно править код: есть ошибки, есть возможность ускорить рендеринг, но в общем следует переходить к другому способу - Bidirectional Ray Tracing (двунаправленный рейтрейсинг), а от него плавно переходить на Metropolis Light Transport.

В целом, желаемый результат получен. Видимо на этом, с рейтрейсингом я закончил.

Фотонные карты

2012-02-14T09:14:00.003+04:00

Фотонные карты - один из видов biased рейтрейсинга. Имитирует процесс натурального освещения. Очень прост, спокойно выдает отражения, мягкие тени, каустики и пр. красивости. Но(!) долго работает, "шумит" и жрет прорву памяти.

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

Я сделал крайне грубый набросок и сильно упростил процесс

Посмотрим на других знакомых и пошагово весь процесс
Дальше →

Стэнфордский дракон

2012-02-13T10:33:00.000+04:00

Стэнфордский дракон (Stanford Dragon) - модель, полученная с помощью 3D-сканера. Часто применяется для графических тестов наравне со счастливым буддой или кроликом. Традиция такая. По времени, дракон рендерится не хуже того же бегемота, а вот с построением BVH-дерева уже сложнее и дольше: порядка 23 секунд на дерево (независимо от размера итоговой картинки).

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

Код Metropolis-Hastings для буддаброта

2012-02-12T14:19:00.000+04:00

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

Первое, что приходит в голову отрендерить в большем разрешении, но есть предел: памяти не хватает и очень долго получается. Тогда приходит мысль вторая - рендерить только нужный кусочек, растягивая аналоговые координаты комплексной плоскости до размеров дискретного окна. Но(!) есть точки, чьи орбиты настолько велики, что они бегают по всей поверхности, оставляя на нашем маленьком кусочке свои кривые. Рендеря только кусочек буддаброта мы не учтем эти точки, их орбиты будут потеряны, а это нехорошо.

Получается, что для построения кусочка нужно просчитывать все точки буддаброта и чем больше увеличение, тем выше разрешение, количество точек увеличивается до колоссальных объемов и процесс растягивается до десятилетий. Оно нам надо? Не надо. Поэтому берут алгоритм Метрополис-Хастингса (Metropolis-Hastings) и рисуют с помощью него.

Я не стал заморачиваться и строить свое решение, а взял код на Си, сделанный Александром Босвелом (Alexander Boswell), и портировал его на C#. Не забыв, конечно же, обернуть его в удобную графическую оболочку.

Получился неплохой исходный код буддаброта на метрополис-хастингсе, на C# и с графической оболочкой. Код немного мудреный, но вполне можно разобраться по комментариям и названиям функций. Есть небольшие ошибки с координатами, но это мелочи.

Приложение: GaneshaBench_Metropolis-Hastings_1.0.4422.21200.zip
Исходный код: GaneshaBench_Metropolis-Hastings_src_1.0.zip

Зеркальный бегемот

2012-02-11T08:30:00.000+04:00

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

Ошибок было две:
1. Некоторые модели составные, а я сглаживал только большую часть опуская такие детали как руки, ноги, уши и пр.
2. Я неправильно интерполировал нормали (пропускал одну из составляющих). Теперь все нормально и есть простор для небольшой оптимизации: предрасчет и сохранение промежуточных коэффициентов интерполяции.

Замечена проблема с тенями - квадратит и полигонит в косых лучах. Рассмотреть детали можно
Дальше →

Буддаброт - исходный код

2012-02-10T05:30:00.000+04:00

В продолжение темы Как построить буддаброт?, наконец-то сделал микросайт для исходников и бинарников графических поделок. Перенес туда HyperFractal и тестовое приложение для постройки буддабротов - GaneshaBench. Исходники рендера буддаброта на C# - прилагаются.

Приложение: GaneshaBench_1.0.4422.18242.zip
Исходный код: GaneshaBench_src_1.0.zip

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

Некрасивый интерфейс

2012-02-09T06:00:00.000+04:00

Некрасивый, но, большей частью, удобный и устраивающий заказчика интерфейс.

Как обычно, заказчику - все-равно, лишь бы "переделали, но чтобы стало как было". На вопрос "а что это за кнопка", заказчик отвечает - "не знаю, наверное журнал", или просто тыкал пальцем и удивленно восклицал "а! так это ж переключение режимов". Поэтому глубина проработки интерфейса целиком инициатива разработчика, всем остальным глубоко на...

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

Дальше →

Гладкий мальчик

2012-02-08T11:11:00.000+04:00

Сделал интерполяцию нормалей вершин треугольников. Нормали экспортируются Блендером (поставить галку "Include Normals"), остается интерполировать нормаль в точке пересечения луча с треугольником.

Результат есть, но что-то не очень: или Блендер экспортирует криво, или я где-то считаю неправильно. Стрелки показывают: было → стало

E Ink Perl под микроскопом

2012-02-07T07:30:00.000+04:00

На выходных под окуляром микроскопа - экран на электронных чернилах, конкретнее - E Ink Perl электронной читалки Digma e501.

Отбросим всё, что знали об электронных чернилах и попробуем исследовать самостоятельно. С оптикой в этот день не заладилось: что-то мутно получается, но что-то видно. Увеличении приблизительно x100.

Поверхность неровная, испещрена витиеватыми углублениями, что делает экран матовым и похожим на бумагу(?) Рассматривать будем кусочек цифры "6" и точку рядом с ней. Здесь есть и округленность цифры, и квадратность точки.

Белое поле, видны гранулы. Форма у них не шар (как в теории), а шестигранная сота. Видна "грязь", оставшаяся от предыдущих ихображений, а может быть, это незаполненное гранулами пространство. Видимо, эта "грязь" и делает экран серым.
Дальше →

Как построить буддаброт?

2012-02-06T14:28:00.000+04:00

Буддаброт строится приблизительно так же как и мандельброт, только больше и дольше.

Для каждой точки на экране заводится счетчик. Далее берется случайная точка, в цикле сдвигаем ее понемногу на каждом шаге и запоминаем новые координаты, дальше смотрят улетела она в бесконечность или нет. Вот тут наступает разница: если в мандельброте нам нужны точки которые входят в множество, то здесь мы ищем точки которые не входят в множество. И если точка не входит, то мы наращиваем ее счетчик и счетчики всех точек полученных в цикле. Т. е. работаем не только с точкой, но и с кривой по которой она бежала в цикле. Кривая называется орбитой (orbit trap).

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

Простой алгоритм приводить смысла нет (он простой), а вот оптимизированный уже интересно. Оптимизация состоит в том, что буддаброт:
1. Симметричный - координаты найденных точеку можно симметрично дублировать, т. е. расчитали одну точку, а нарисовали сразу две, рассчитали 10 - нарисовали 20.
2. Можно быстро отсеивать точки, если они попадают в определенные области.

Далее алгоритм. xySeq[] - массив точек через которые проходит орбита убежавшей точки, их и нужно рисовать.

Дальше →

Mandelbulb DE под OpenCL

2012-02-05T13:19:00.000+04:00

Было трудно портировать C# код в Cloo-кернел для расчета мандельбульба, да еще и с помощью DE. Код мутный, но только на первый взгляд. На второй тоже трудно, но в принципе уже понятно.

Я как мог оставил комментарии и зачем-то перевел их на русский. Большая часть параметров захардкожена, зато в коде есть нормали и эмбиент оклюжн (AO), и, самое главное, всё это грузится и выполняется под Cloo. Код загрузки на C# не представляет трудности, примеров в инете много. Для начинания расчета гиперфракталов на GPU - самое оно.

Дальше →

Воксельный Mandelbulb на OpenCL

2012-02-04T11:41:00.000+04:00

Загрузить кернел и получить данные от GPU несложно, труднее было портировать кернел. Далее простейший кернел под Cloo OpenCL: большинство параметров захардкожено, но для начала вполне подойдет.

Кернел легко модифицируется под Juliabulb и др. гиперфракталы. Одинарная точность (float) и native_ функции - для небольшого ускорения.

Дальше →

Работа с пикселями на C#

2012-02-03T10:00:00.000+04:00

Пора накидать кодных крошек. Быстрая работа с пикселями Bitmap в Windows Forms на C#. Put и Get пиксель - это ужасно медленно, а здесь быстро и есть работа с байтами.

//// для примера

int bitmapW = 800;
int bitmapH = 600;

Graphics g = Graphics.FromHwnd(this.Handle);
Bitmap bitmap = new Bitmap(bitmapW, bitmapH, g);
Random rnd = new Random();

//// начало

// не совсем корректно, но предполагаем, что формат цвета либо 24-бита, либо 32
int byteLen = bitmap.PixelFormat == PixelFormat.Format24bppRgb ? 3 : 4;

// блокируем битмап: только для записи, но можно и для чтения, и не только
BitmapData bitmapData = bitmap.LockBits(
    new Rectangle(0, 0, bitmap.Width, bitmap.Height),
    System.Drawing.Imaging.ImageLockMode.WriteOnly,
    //System.Drawing.Imaging.ImageLockMode.ReadWrite,
    //System.Drawing.Imaging.ImageLockMode.ReadOnly,
    bitmap.PixelFormat);

// создаем буфер для пикселей битмапа
// копируем в буфер байты цвета пикселей битмапа
byte[] bitmapBuffer = new byte[bitmapData.Stride * bitmapData.Height];
Marshal.Copy(
    bitmapData.Scan0,
    bitmapBuffer,
    0,
    bitmapBuffer.Length);

for (int y = 0; y < bitmapH; y++)
{
    int strideY = bitmapData.Stride * y; // небольшая оптимизация
    for (int x = 0; x < bitmapW; x++)
    {
        //// этот кусок нужен для демонстрации, заполняет пиксел случайным цветом
        int c = rnd.Next();
        byte r = (byte)(c >> 16);
        byte g = (byte)(c >> 8);
        byte b = (byte)(c & 0xff);
        ////
    
        int index = strideY + x * byteLen; // небольшая оптимизация
    
        // сохраняем цвета каналов RGB пиксела в буфер
        bitmapBuffer[index + 0] = b;
        bitmapBuffer[index + 1] = g;
        bitmapBuffer[index + 2] = r;
        
        // если 32-битный формат цвета, то нужно выставить байт прозрачности
        if (byteLen == 4)
        {
            bitmapBuffer[index + 3] = 255;
        }
    }
}

// копируем байты цвета назад в битмап
// разблокируем битмап
Marshal.Copy(
    bitmapBuffer,
    0,
    bitmapData.Scan0,
    bitmapData.Stride * bitmapData.Height);
bitmap.UnlockBits(bitmapData);

//// битмап обновлен
//// в данном примере он заполнен цветным шумом

Время Jazz

2012-02-02T10:38:00.001+04:00

Пока разработчик железок занят сложной командировкой, я прорабатываю для него работу с программируемой релюшкой Jazz фирмы Unitronics. Задача простая - сделать настраиваемую систему с двумя таймерами: время работы и время ожидания. Кнопка пуск - работа - ожидание - работа - ожидание... кнопка стоп.

Чуть позднее меня попросят добавить к оставшемуся времени, заданные временные промежутки, сделать шрифт заглавным, сократить надписи до "РАБ", "ЗАД", "ПАУЗ", "НАСТР" и прочий хаос, и маразм. А сейчас, подробнее...

Дальше →

Бенчмарк рейтрейсера

2012-01-22T09:00:00.000+04:00

Потестил несколько разных моделей с разным количеством полигонов: от 10 000 до 100 000, картинки ниже. Выводы интересные: время рендеринга зависит не от количества полигонов в сцене, а от размера и количества видимых в окне полигонов. Это нормально, больше больших полигонов - больше точек нужно просчитать. Хорошо заметно на моделях "Анубис" и "Лампа" (число полигонов почти равное).

BVH хорошо скрадывает просчет пустых и слабо заполненных пространств: при рендеринге люстры, рейтрейсер быстро выводил ножку люстры и медленно просчитывал "висюльки".

Мыша, 21000 полигон, 2 минуты

Люстра, 94000 полигонов, 2 минуты
Дальше →

Текущий срез

2012-01-20T12:42:00.002+04:00

- Полноценная камера с произвольным положением, вращением и направлением взгляда в сцене.
- Тени.
- Отражение и переотражения.
- Загрузка моделей Wavefront OBJ.
- BVH на бинарных AABB-деревьях: оптимизирован просчет лучей.

Мальчик с серпом. ~16000 треугольников. Двойные переотражения. Отрендерен за девять минут в разрешении 2000x2000, картинка уменьшена в два раза

Можно взглянуть поближе и
Дальше →

Модели из блендера

2012-01-20T12:05:00.000+04:00

Moray - это хорошо, но Блендер (Blender) - лучше. Сделал простейший экспортер моделей. Изначально планировал взять канонические .3ds, но быстро передумал на Wavefront .obj - он намного проще и мне пока нужны только модели.

Блендер в текущей инкарнации дорос до полноценной установки (без маяты с установкой и прикормом питонов), а новый интерфейс позволяет начать с первой минуты хоть что-то делать.

Сюзанна - модель из блендера

Модели в формате obj без проблем экспортируются из Блендера. Внутри набор вершин, грани, нормали и текстурные координаты. Этого достаточно, чтобы не протухнуть среди тороидов и непонятных хреновин.

Стрельба по кубикам

2012-01-18T14:06:00.001+04:00

Удалось оптимизировать построение бинарного BVH AABB-дерева. Звучит жутко, но работает в три раза быстрее, немного глубже, зато треугольников в листьях меньше. Пруф

Итак, с самого начала.

Через каждый пиксел выстреливается как минимум один луч. Затем проверяем с какими треугольниками он столкнулся и расчитываем цвет точки пересечения. Главный вопрос "с каким(и) треугольником(ами) луч столкнулся?"

Дальше →

Сглаживание

2012-01-18T11:04:00.000+04:00

Сглаживание, антиалиасинг (antialiasing) сделать просто. На выбор: полноэкранный суперсэмплинг (FSAA, SSAA), адаптивный сэмплинг и стохастический. Сделал суперсамплинг - каждый пиксел рендерится несколькими лучами, результат усредняется. Границы полигонов выглядят сглаженными.

Адаптивный делать не хочу, в сторону стохастического посмотрю позже.

Карта нормалей

2012-01-16T16:32:00.000+04:00

Несмотря на черно-белые скрины раннего рейтрейсера, он вполне себе работает в цвете. Цвета треугольников модели вычисляются на основе нормалей: синий - то что более параллельно экрану, красный - более перпендикулярно.

Тени, отражения - всё есть, но не совсем корректно, т. к. отражаются и затеняются все треугольники: и те что видны (передние), и те что нет (задние). Так что загогулина иногда становится полупрозрачной. Явление временное, пока не появится менеджер сцен и обработка моделей как сплошных (solid), а не набором треугольников.

Оптимизация рейтрейсера

2012-01-16T16:24:00.000+04:00

Оптимизация получена с помощью BVH (Bounding Volume Hierarchy) - иерархия ограничивающих объемов и AABB (Axis Aligned Boinding Boxes) - кубики ориентированные по осям). Можно загружать модели с тысячами треугольников и рендерится это все за приемлемое время: если раньше уходило от получаса до полутора часов (терпения дождаться не хватало), теперь уходит 3-7 минут. С отражениями и тенями.

Карта высот, модель построена в Moray. За основу взяты юпики ЖЖ beatcracker

Cцена вписывается в параллелепипед. Объем разбивается плоскостью на два других. Они взвешиваются, если не понравилось - каждый разбивается на еще два. Опять взвешиваются... Вертеп работает пока весы не покажут достаточно. Весы называют SAH (Surface Area Heuristic). Грубо, это произведение площади параллелепипеда на количество треугольников в нем.

Главная задача - оптимально разбивать на два объема. Я пока тупо делю на равные части, но время работы уже сократилось сказочно.

Йожъ
Дальше →

Трассировка треугольников

2012-01-12T15:22:00.001+04:00

Переписал рейтрейсер: вдумчиво и с расстановкой. Фигуры строятся из полигонов, т. е. треугольниками, что позволяет строить сложные сцены. Чтобы не мучиться с ручным вводом координат, взял Moray (любимый редактор для POV-Ray) и экспортировал из него UDO-сетки, т. е. в трассировщике лучей есть зачатки загрузки UDO-mesh'ей.

Построение пока что без оптимизации, но уже с отражениями и тенями. Строятся сцены долго, поэтому на следующем этапе буду строить дерево объектов, а объекты разбивать на сетку (kd-tree или bvh, скорее всего последнее).

Объекты нужны для имитации внутренностей предметов. Полигоны дают только поверхность, что усложняет работу с преломлением/рефракцией (линзы) и внутренним переотражением лучей (алмаз).

Очень сложный объект
Дальше →

Раскраска буддаброта

2012-01-10T10:44:00.000+04:00

В буддабротах главное раскраска: черно-белый должен сиять, цветной - похож на космические фотографии NASA, но можно и поиграться.

Инвертированный и повернутый буддаброт сделан с помощью метрополис-хастингса (Metropolis-Hastings). RGB-каналы с разными весами, кленовый лист

Четкость/резкость картинки зависит от количества итераций: меньше итераций - четче картинка. 2000 итераций, сутки на обработку
Дальше →

Вскрытие процессора

2012-01-06T00:10:00.002+04:00

В голове отложилась мысль, что это один из первых пентиумов, но смотря только в микроскоп можно увидеть тавро, а гугление подсказывает, что "An Intel internal manufacturing name '80G4C' appears on 80486 DX2 3.3V die".

Это Intel 486 DX2. В интернетах есть профессиональные фотографии как в ложных цветах, так и в нормальной расцветке. У меня же по прежнему в золото-меди.

Увеличение 160хэ, картинка с запасом умещается в один миллиметр

Трубопроводы электронов
Дальше →

Микроштатив

2012-01-04T23:48:00.000+04:00

Штатив из фотоувеличителя закончен: УПА-510 превратился в микроштатив для микроскопа. Фотоаппарат кладется сверху, спуск затвора через USB и CHDK (КРЕН5А + 12В батарейка).

Фоткаю "разобранный" процессор

Mandelbulb DE на GPU

2011-12-30T11:56:00.001+04:00

Руки дошли сделать рендер мандельбульба на DE под OpenCL.

Долго не мог понять почему рендер на видеокарте занимает около полутора минут, если на процессоре в два потока оно проходит за 21 секунду. Даже на слабой (в плане расчетов) видеокарте ноута - слишком долго.

В итоге, оказалось, большую часть времени занимает компиляция кернела GPGPU. Сделал кэширование бинарников кернела и последующую загрузку при повторной загрузке. На сильно неоптимизированой программе - 16 секунд, и какие-то левые артефакты. После небольшой оптимизации - 10 секунд. В сравнении с 21сек на CPU - это уже хорошо.

16 сек пруф
Дальше →

Scientists claim to break light-speed barrier

2011-12-29T12:09:00.001+04:00

Из буддабротов можно выжать больше

Антагонист

2011-12-27T12:59:00.000+04:00

У буддаброта (buddhabrot) есть антагонист - Анти-буддаброт (anti-buddhabrot). То же самое, но точки не улетают в бесконечность. Далее он искрит

На больших итерациях получаются закопченные рыцари, на маленьких - злые телепузики

Дальше →

Metropolis-Hastings

2011-12-27T09:52:00.000+04:00

Metropolis-Hastings - один из методов для получения большого увеличения (deep zoom) в буддабротах. Обычный метод при большом увеличении затянется на пару недель. И чем-то этот процесс напоминает ручную проявку фотографий: плещешь-плещешь в ванночке, и вот она медленно проявляется. Закрепляем в PNG

Главным в буддабротах по прежнему остается раскраска. Плохо проработанный вариант, где-то час на обработку:
Дальше →

С чем едят буддаброт

2011-12-23T09:09:00.000+04:00

Буддаброт (Buddhabrot) - тот же мандельброт, только в профиль, и это не шутка. Красивая хреновина с кучей деталей, а для раскрашивания используются космические технологии (и это опять не шутка).

Попытка повторить картинку из википедии. Времени доработать не хватило, как есть

Дальше →

Native функции GPU

2011-12-22T10:44:00.001+04:00

В наборе команд GPU есть т. н. native_ функции (native_sin, native_cos, native_sqrt, ...) которые выполняются быстрее, чем их родственники sin, cos и пр. Их немного, они не такие точные, но(!) они быстрее. Для предпросмотра и работы с 3D вполне хватает.

Для сравнения я засунул их в код кернела из поста Клуу и засек ручным хронометром время рендеринга. Внимание(!), 11 секунд против 15. Выигрыш - 4 секунды, это много, и это - хорошо.

Слон кирпич безумная пчела

2011-12-21T07:30:00.000+04:00

Детям нравится.

Клуу

2011-12-20T16:36:00.001+04:00

Какое-то время я не мог решить CUDA или OpenCL, пока не решил скачать CUDA SDK. Увидев размер дистрибутива CUDA, скачал микронный Cloo. Первое знакомство, осваивание и рабочий образец получился в тот же день.

C#.NET 2.0 + OpenCL (Cloo), кернел совершенно не оптимизированный: просто перенес код из C# на OpenCL-Си.

Первый, пробный запуск - мандельбульб вид сверху, 16 на 16 пикселей, два цвета :)

Далее картинка 800x800px. Для каждого пикселя нужно выполнить 800 пакетов вычислений. В каждом пакете - синусы, косинусы, арксинусы, возведения в восьмую степень, извлечения квадратов и пр. Итого 800x800x800 = 512 миллионов пакетов на всю картинку.

Результат:
CPU (Voxel) = 3 мин. 27 сек.
GPU (Voxel) = 15 сек.

Для сравнения: CPU (DE) = 27 сек., т. е. на видеокарте уже можно получить рендеринг в реальном времени с хорошей частотой кадров.

Результаты замеров вместе с компиляцией кернела, загрузкой в память GPU... один хрен, разница существенная и заметна невооруженным взглядом.

Подробнее о системах на которых проводил испытания
Дальше →

DE архитектурнее

2011-12-18T07:30:00.000+04:00

Мандельбульб четвертой степени на основе distance estamation (DE), появляются беседки (1), мосты (2) и колонны (3)

В обычном брутфорсном алгоритме такого нет: мандельбульб выглядит кактусом в миксере, плюс бесконечные спуски и разломы. Формулы немного различаются?

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

Дальше →

Звезда смерти или большой плюх

2011-12-17T13:11:00.000+04:00

Большой плюх (мандельбульб 32-й степени) 2000x2000 пикселей

Посмотрим ближе
Дальше →

Distance Estimation Mandelbulb

2011-12-16T13:03:00.002+04:00

Поигрался с экспериментальным движком HyperFractal на основе distance estimation. Осталось несколько нерешенных вопросов.

Мандельбульб четвертой степени в высоком разрешении (2000x2000)

TRON, изоморфы и мандельбульбер

2011-12-15T09:24:00.000+04:00

Смотрим кадры из Трон - Наследие (TRON Legacy), затем кадр из Mandelbulber

TRON, здания изоморфов

Мандельбульбер
Дальше →

Визуализация работы машины

2011-12-14T10:26:00.001+04:00

Никогда, никогда, вообще никогда не делать таких...

Цветные диаграммы

2011-12-14T09:56:00.001+04:00

Продолжаю лепить интерфейс для проекта. Главный экран переработан (предыдущий вариант в посте "Черный фон, белые буквы"). Состояние системы легко считывается метров с восьми. Пора подключать тестового оператора, для едкой критики и ценных советов

Анимированный вариант
Дальше →

Myth - History of The Making

2011-12-06T08:47:00.001+04:00

Нужно быстро вытащить один или несколько уровней из старой игрушки, засунуть их в бесплатный редактор уровней Tiled, из которого получить уровень в виде XML-файла с привязанным к нему набором тайлов (tileset) в виде PNG... который можно засунуть... да хотя бы в MelonJS.

На примере Myth - History In The Making, вышедшей на ZX Spectrum'е.

Берем типичный игровой экран, оцениваем "на глаз" размер тайла: где-то 8x8 пикселей получаем.

Затем грузим в Paint.NET полную карту прохождения уровней в виде одного большого GIF'а и режем ее на отдельные уровни. Карту игры берем на том же World of Spectrum.
Дальше →

Спирограф

2011-12-03T22:21:00.001+04:00

Спирограф. Не фракталы, и не три дэ: пластина с дыркой, колесо с отверстиями и пара-тройка цветных ручек

Почти гравюра
Дальше →

Черный фон, белые буквы

2011-11-17T11:42:00.001+04:00

"У вас какой-то детский подход: говно, оно ведь не только коричневое."

Заказчик рассуждает об интерфейсах

Разработка начинается "сделайте нам... и чтобы была графическая панель". Что будет отображаться на панели, заказчик не знает и ему все равно, но(!) когда абстрактное "это " будет готово, заказчик начнет ныть и конючить: "Что это? А как тут нажать? А вот нам бы вывести ток, мы иногда по таблице считаем." Поэтому интерфейс - головная боль разработчика. И, да, не давайте разрабатывать интерфейс программистам. Они привыкли к инструментам, а не то, к чему привык человек. Только делать интерфейс будут все-равно программисты. Они же будут его исправлять и дополнять. Каша из букв, цифр, иконок такой-то матери... все это будет.

К тому же, заказчику совершенно не нужен интерфейс, ему нужно "чтобы работало", а интерфейс ему только мешает. Дайте больших прорезиненых кнопок и больших ярко-красных лампочек, но чтобы цифры были. И, да, чтобы параметры системы было видно... и еще бы уровень показать, да чтобы...

Дальше →

Плохой, но понятный интерфейс

2011-11-17T10:54:00.001+04:00

Картинка ниже - пример плохого интерфейса на 17" панели оператора. Не сенсорной. Управление мышкой и клавиатурой.

Тем не менее, такой интерфейс понятен заказчику и он легко им владеет. О чем это говорит?

Дальше →

Насос Г

2011-10-14T03:30:00.000+04:00

Перечитал и ужаснулся, но править не буду.

Оставлю себе в назидание.

Закончен очередной интерфейс для промышленного объекта. Обычно принято расписывать какие разработчики молодцы и какие подходы они использовали: цвет заглядение, оператор нажимает кноки на 100 миллисекунд быстрее... Я буду ругать. Свой же интерфейс.

Система управления насосом. Насос может качать, а может работать в цикле: 20 часов качает, три часа стоит, затем опять 20 часов... пока не выкачает всё Г. Мощность 160 киловатт.

Управляется ценными прорезиненными переключателями и кнопками. Параметры объекта задаются на сенсорной панели. Плохо, что наэкранные кнопки маленькие. Пальцем нажимаются, но ощущется дискомфорт. Надо больше, но экран не резиновый, а всего-лишь 4.3"

Плохо, что текущие отображаемые параметры выравнены ёлочкой. Это очень плохо, но ширина цифрового поля вывода фиксирована и либо елочкой, либо единицы измерения будут отстоять на разном расстоянии, что еще хуже.

Дальше →

Focal Fuse

2011-10-12T14:46:00.000+04:00

Из неизданного. Как писатели пишут в стол, так и тут - из под стола, недоделанный и незаконченный. Еще один эксперимент с интерфейсом.

У любимой утилиты TuFuse консольный интерфейс и пусть таким же остается, но захотелось поэкспериментировать: поднадоели мне стандартные окошки, кнопки, закладки, хочется чтобы интерфейс дышал. MS Metro UI - тебе привет.

И главное - никакой графики: как был интерфейс текстовым, так и остался. Пожалуй, в дальнейшем буду клепать именно такие "просторные" интерфейсы. Все ниже отскриншотенное написано под .NET 2.0, и никаких DHTML и др. блядских кросс-веб-десктоп-технологий. Awesomium - привет!

Все, что подчеркнуто - кнопки: черные - переключают окна/страницы, оранжевые - выполняют действия. Окно программы - таскается по десктопу за верхнюю часть окна, ресайзится - за серый диск в правом, нижнем углу. Индикаторы наличия утилит TuFuse и dcraw в левом, нижнем углу: черный - утилита доступна, бледная немочь - утилита не найдена.

Список картинок

Дальше →

POV-Ray

2011-10-12T09:00:00.000+04:00

Все-таки откопал что-то из POV-Ray насчет рендеринга фракталов. Ниже главное окно POV-Ray консоли. Видно как подгружается экспортированный из HyperFractal'а текстовик с просчитанными данными (123.txt).

Графическое разрешение в HyperFractal'е и POV-Ray должно совпадать, иначе получим кубики (об этом в самом конце поста). В результате получается то, что ниже.

Дальше →

Сепия и свечение в HyperFractal DE

2011-10-11T14:38:00.000+04:00

...и совсем последний пост про фракталы. Внезапно нашел неопубликованное.

На каком-то из этапов я использовал POV-Ray для визуализации просчитанного гиперфрактала. Результат был такой же как и в текущем моем рендере. Если не считать того, что в POV-Ray можно было изменять характер текстуры фрактала, добавлять источники освещения и пр. пр., лишь бы не менялся ракурс и положение камеры. Из минусов - большой размер текстовика сцены для рендера. При разрешении 800x800 получалось порядка 100 мегабайтный текстовик просчитанных треугольников.

HyperFractal обсчитывал фрактал и топорно визуализировал. Затем можно было экспортировать просчитанные точки в текстовик для POV-Ray. Дальше POV-Ray - рендерил, т. е. требовалось дополнительное время. Картинок тех экспериментов не осталось, но впечатлил редактор текстовика-сцены: он спокойно переваривал и позволял редактировать 200-мегабайтные тексты сцены.

Потом, когда я целиком перешел на рендер собственного производста и экспериментировал с distance estimation для mandelbulb, я добавил эффект свечения и сепии... получилось неплохо, но потом забросил. Зря наверное, получалось эффектно.

Дальше →

Фракталы в большом разрешении

2011-09-26T15:06:00.000+04:00

Для закрытия темы рендеринга фракталов силами C#, две картинки большого разрешения: 2000x2000 и 3000x3000. Оверсэмплинг - замечательная вещь. Вблизи, один-к-одному, оно как-то не очень и пиксели.

Mandelbulb, DE (distance estimation), Ambient Occlusion. По кликам доступны картинки в полном разрешении: после клика, где-то снизу есть ссылка "в другом размере" - "оригинальный размер".

Дальше →

Рендер фрактала на C#

2011-09-26T10:33:00.001+04:00

Один из последних экспериментов с рендером гиперфракталов на C# с использованием distance estimation (DE). Кроме мандельбульб (mandelbulb), я пробовал Menger Sponge и его модификации. Результат по скорости очень хороший, но смысла продолжать рендерить на CPU я не вижу: нужно переходить на GPU и все считать там. C# или C++ особой разницы в производительности не заметно, а вот сам DE прирост дает ощутимый, но картинка становится слишком "гладкой". На вкус и цвет...

Ниже кусок кода отвечающий за расчет фрактала под .NET C#. Он уже заточен под многоядерность и многопоточность. Вполне достаточно для экспериментов при небольшой доработке напильником. Там же заложен Ambient Occlusion и зачатки работы с тенями (интересующийся - найдет самостоятельно).

Vector3d и прочие Matrix4d берутся из подключенной сборки OpenTK. ZBuffer хранит цвета расчитанных пикселей, т. е. после расчета можно делать постпроцессинг (ранее я так обсчитывал тени). Правда, это накладывает ограничение на максимальный размер картинки: памяти может не хватить, но ничто не мешает сразу же рисовать точки на экран, минуя буфер.

И, да, практически - это рейтрейсер. Собственно так оно и делается.

Дальше →

УПА-510

2011-09-16T11:00:00.000+04:00

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

Вы точно это ели

2011-09-09T20:18:00.000+04:00

...и не один раз, и по несколько штук за раз: вареными, жареными, солеными. С виду ничего примечательного, но вблизи - орёл!

Оно же - чуть дальше, зато видно "шерсть"

Дальше →

Фотопринтер

2011-09-06T09:12:00.000+04:00

Сканировал фотографию в единственном экземпляре и обратил внимание на цветные полоски на отсканированном изображение. Закралось подозрение что фотка распечатана на фотопринтере.

Выставил разрешение сканера на максимум оптики - 1200 dpi

Потом достал микроскоп и заглянул в него. Увеличение 80x. Цветных полос не видно, крупинок тонера не видно. Цветные кляксы - видно. Фотопринтер?

Дальше →

Туалетная бумага, фланель, резина и липкие листочки

2011-09-05T19:16:00.001+04:00

Для начала, фланель (мягкая тряпочка шла в комплекте с монитором), обработка в TuFuse:

Дальше →

Helicon Focus vs TuFuse

2011-09-05T15:16:00.000+04:00

TuFuse - консольная утилита для сложения фотографий с разной экспозицией... псевдо-HDR в ней можно делать бесплатно. Попробовал засунуть в нее фотки с разной глубиной фокуса. Иногда что-то получается не хуже чем в Helicon Focus, но фотографии должны быть точно позиционированы: дрожания рук и прочие подвижки изображения приводят к фееричной мозаике.

Итог: TuFuse - бесплатный, не всегда резкие снимки, требует точного позиционирования. Helicon Focus - оставляет артефакты, но делает более резкие снимки. Пока что буду использовать TuFuse.

TuFuse, резина с покрытием, 80x

Helicon Focus, сложены те же самые четыре кадра
Дальше →

Юннат-2П

2011-09-05T11:16:00.000+04:00

Пока не сломал и не передоделал, сделал контрольный снимок:

Увеличение: 80x .. 400x
Сменные объективы: 8x; 20x.
Окуляр: 10x + 2x линза Барлоу.
Материалы: чугуний, стекло, немного пластика.

Макро и микро

2011-09-01T21:23:00.001+04:00

Поймал мошку, положил под микроскоп и сделал снимок в режиме макро.

Засунул между мошкой и фотоаппаратом микроскоп и сделал снимок. Режим теперь можно назвать "микро". Настройки в фотоаппарате не менял.
Дальше →

Helicon Focus vs Registax

2011-09-01T20:49:00.000+04:00

Сравнил Helicon Focus и Registax. Первый стоит денег (через 30-ть дней), второй бесплатный. Первый отлично подходит для микрофото, второй похоже для астрофото (еще есть Avistack, но у него проблемы с большими картинками). Registax умеет отслеживать перемещение объекта по кадру, Focus - нет.

Helicon Focus умеет строить неполные 3D-модели, и выводить их под анаглиф и пр. стерео. Оно еще много всего умеет, но стоит денег.

Сравнение...
Дальше →

Тонкие вещи

2011-08-31T21:41:00.003+04:00

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

Швейная игла. 400х, три снимка сложены в регистаксе.

Дальше →

Экраны телефонов

2011-08-30T22:57:00.002+04:00

Экраны телевизоров фоткают все, кому не лень, а я возьму и сделаю сравнительный... Увеличение одинаковое (где-то 80x-100x), условия одинаковые, телефоны разные. Фоткать было тяжело, экраны гасли от усилий.

Экран телефона МТС Huawei 128x128

Экран телефона Sony-Ericsson k810i 240x320
Дальше →

Мусор

2011-08-30T22:41:00.000+04:00

В капле воды много мусора и водорослей. Что из них что, я пока только догадываюсь, хотя есть умная книга Определитель пресноводных беспозвоночных Европейской части СССР.djvu
(20.85 Мб). Помогает мало. Например, что это ниже: водоросль или засохшая амеба?

Дальше →

Монеты

2011-08-29T22:32:00.000+04:00

Рассматривать в микроскоп монеты - скучно, но кое-что интересного есть и там. Например, логотип монетного двора. Панорамы-склейка из нескольких фото.

Московский Монетный Двор. 10-ть рублей.

Дальше →

Простохищник

2011-08-28T20:39:00.000+04:00

Нашел еще одного простейшего или кто это? Оно питалось и резвилось. Видел у него реснички: ловко загребает, но видно на грани глюка, на видео кое-где проступают впереди по ходу движения.

Дальше →

Трагедия в капле воды

2011-08-27T21:00:00.000+04:00

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

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

Крыло мухи

2011-08-27T06:00:00.000+04:00

Вечером на балкон пробралась толстый образец мухи. Пришлось поймать и обобрать. Теперь я точно уверен, что режиссер фильма "Муха", не раз и не два разглядывал многократно увеличенное изображение насекомого. Любителям проблеваться на фотографии насекомых стоит пропустить этот пост.

Дальше →

Безворсовые чистящие салфетки

2011-08-26T20:51:00.000+04:00

Ткани вообще трудно фотографировать - нужна большая глубина резкости. Поэтому на черном фоне, чтобы смотрелось эффектнее.

Дальше →

Жидкости

2011-08-25T20:46:00.000+04:00

Окунемся немного в жидкости и посмотрим как там: капля на предметный стол и крутим фокус. Можно спускаться и подниматься во внутренности капли.

Что-то вроде крови пополам с еще чем-то. Цвет действительно оранжевый.

Дальше →

Микрофотография

2011-08-25T20:38:00.000+04:00

Достал старый, но добрый микроскоп, почистил линзы, протер полой футболки предметное зеркальце и вперед. Итак, приступим.

Частицы тонера от 3 до 10 микрон, притянутые к бумаге электростатикой и вплавленные в белое полотно барабаном...

Дальше →

Сортировка

2011-08-03T13:04:00.000+04:00

После сортировки ситуация немного улучшается, но все равно не решает возникшие проблемы. Нужны например kd-деревья.

Преломление

2011-08-02T14:40:00.003+04:00

Собственно рефракция работает, но есть непорядок в порядке отрисовке объектов: их приходится добавлять в порядке удаления от камеры и это не всегда спасает.

В принципе решается алгоритмом типа kd-деревьев. Нужно попробовать.

Координаты

2011-08-02T10:01:00.003+04:00

Опять поплыли координаты. Положение объектов ведут себя неадекватно, где и что размещать получается методом подгонки, рефракция работает, но сложно проверить точность. Время затачивать код.

Картинка размером 2000х1600 в отражениях видны тени.

NwRays

2011-08-02T09:18:00.001+04:00

Just Raytracer

2011-08-01T23:59:00.000+04:00

Просматривал скриншоты от HyperFractal'а и решил попробовать сделать обычный рэй-трейсер: ага, те самые зеркальные сферы на плоскости.

Пять часов криво-кода и вот результаты: освещение от нескольких источников накладывается (дифуз, спек), отражения какие-то есть, что-то даже с рефракцией получилось... Пожалуй, буду допиливать.

...и, пожалуй, нужно поставить цель - стеклянный бокал вина на столе.

Версия для Linux

2011-06-28T16:15:00.000+04:00

Пересобрал версию 1.0 под Linux (Xubuntu 10.04). Использовал MonoDevelop. Изменений немного: убрал библиотеку для плавающих окошек и все заработало само.

Исходники: HyperFractal_src_1.0_mono.zip

И картинка, чтобы не было скучно:

Версия 1.0 + исходники

2011-05-31T09:30:00.000+04:00

Версия 1.0: HyperFractal_1.0.4168.14804.zip
Исходники: HyperFractal_src_1.0.zip

Пять минут спустя

2011-05-11T23:54:00.000+04:00

Концентрические круги сменяются кубом в концентрических кривулинах, чем-то напомнившего Hellraiser.

Другой АО

2011-05-11T23:35:00.000+04:00

Переделал алгоритм расчета Ambient Occlusion: теперь вполне честный, с учетом соседей.

Дальше →

Ambient occlusion

2011-05-07T21:52:00.000+04:00

Быстренько так реализовал псевдо-ambient-occlusion. Сильно лучше не стало, нужно думать в сторону более канонической реализации.

Дальше →

Зум в кубе

2011-05-05T22:56:00.000+04:00

Сравнивая мой способ рендеринга и DE, получается, что мой дает более четкую (острую) картинку, DE - гладкие, округлые поверхности, но(!) DE - рассчитывает на порядок быстрее, просто охрененно-ощутимо-быстрее. Оставляю в будущей версии два рендера на выбор.

Дальше →

Шар в центре куба

2011-05-05T22:31:00.000+04:00

Пока я делаю новый рендер (на том самом DE), сохраняю некоторые снимки со старого, чтобы позже сравнить. В центре Mandelbox'а - шар, в шаре - шар, ... в кубе, ...

В Яндекс.Фотках, кста, внизу есть ссылка "В другом размере" → "Оригинал" на оригинальный размер картинок. Под катом картинки большого размера.

Дальше →

В большей степени

2011-05-03T20:07:00.000+04:00

Изменений в код придется внести немало, чтобы потом не переделывать по сто раз. Пока что несколько картинок (проверяю некоторые вещи)...

Дальше →

Версия 1.1.x.x

2011-05-01T20:58:00.001+04:00

Перешел на версию 1.1, в ней нужно реализовать все, что начато или не доделано сейчас. Довести до состояния, когда HyperFractal можно будет выложить в свободный доступ.

На последок, кусок Juliabulb'а...
Дальше →

Черно-белое кино

2011-05-01T09:28:00.017+04:00

Надоело "черно-белое кино", один из оригинальных способов раскраски подчерпнул из темы Coloring the Mandelbulb и немного модифицировал. Еще по раскраске можно глянуть в тему Mandelbox Coloring in Mandelbulber?

Mandelbulb

Дальше →

Бенчмарк

2011-04-29T22:45:00.008+04:00

Железо
Intel Core2 Duo T7300 @ 2.00GHz

Расчет теней дается дорого и плохо распараллеливается.

Mandelbulb
Размер = 800х800 пикселей
Расчет точек = 7 мин 53 сек
Тени = 23 сек

Дальше →

IFS сбежавшего времени

2011-04-29T09:47:00.008+04:00

Попробовал изобразить Escape-time IFS (Iterated Function System). В дальнейшем нужно будет заняться более плотно, а пока что Menger Sponge модифицированный под IFS.

Дальше →

Сборка проекта по быстрому

2011-04-29T06:23:00.002+04:00

Банально, но памятку оставить нужно... Не хочу и не вижу смысла ставить Visual Studio на нетбук. Иногда нужно поправить в коде проекта одну цифру, либо добавить пару строк. Для быстрой пересборки проекта достаточно воспользоваться MSBuild.exe который лежит в каталоге с установленным .NET. MSBuild'у достаточно подсунуть файл солюшена (решение, solution, .sln).

Проект собирается в 2008 студии, поэтому использую MSBuild из .NET 3.5. В каталоге с проектом лежит батник build.cmd (название - произвольное), состоящий из одной единственной строки:

C:\WINDOWS\Microsoft.NET\Framework\v3.5\MSBuild.exe HyperFractal.sln

Вычисление Quadray-мандельброта

2011-04-28T19:35:00.011+04:00

// for ex.
int _iterations = 40;
double _bail = 64.0;
double _scale = 2.0;

public override bool IsInSet(double x, double y, double z)
{
    double ctx = Math.Abs( x + y + z);
    double cty = Math.Abs(-x - y + z);
    double ctz = Math.Abs(-x + y - z);
    double ctw = Math.Abs( x - y - z);
    x = 0.0;
    y = 0.0;
    z = 0.0;
    double w = 0.0;

    for (int i = 0; i < _iterations; i++)
    {
        double xx = x * x;
        double yy = y * y;
        double ww = w * w;
        double zz = z * z;

        double wz = _scale * w * z;
        double xy = _scale * x * y;

        double X1 = xx - yy + wz + ctx;
        double Y1 = yy - xx + wz + cty;
        double Z1 = zz - ww + xy + ctz;
        double W1 = ww - zz + xy + ctw;
        x = X1;
        y = Y1;
        z = Z1;
        w = W1;
        
        double radius = x * x + y * y + z * z + w * w;
        if (radius > _bail)
        {
            return false;
        }
    }

    return true;
}

Мандельброт в Quadray-координатах

2011-04-28T17:39:00.016+04:00

Видел раньше на форуме, но сделал только сейчас. Про загадочные quadray-координаты есть в англоязычной части Википедии. Сам фрактал - скучный, но для разнообразия разок посмотреть можно.

Дальше →

Правильные, годные тени

2011-04-27T10:58:00.000+04:00

Уже почти правильные тени, остались мелочи. Где-то в конце поста - небольшая анимация... А мягкие тени - не мягкие, а просто так выглядят. Для мягких теней плотность тени не настоящая. Быстро накидал ослабление плотности от длины тени.

Дальше →

Превью

2011-04-26T23:43:00.000+04:00

Ускорение расчетов

2011-04-26T19:56:00.000+04:00

Для более быстрого обсчета - после запуска HyperFractal нужно отрендерить что-угодно с минимальным разрешением и минимальным шагом (например: resolution = 200; steps = 50), и включить шейдинг по Ламберту.

После первого запуска рендеринга, .NET откомпилирует все необходимые методы, и последующие расчеты будут работать заметно быстрее.

Код для Juliabulb

2011-04-26T19:47:00.000+04:00

//for ex.
double _bail = 4.0;
double _power = 4.0;
double _re = -1.1;
double _im = 0.0;
int _iterations = 8;

public override bool IsInSet(double x, double y, double z)
{
    double nextX = x;
    double nextY = y;
    double nextZ = z;

    int cnt = 0;
    do
    {
        cnt++;
        if (cnt == _iterations + 1)
        {
            break;
        }

        double r = Math.Sqrt(nextX * nextX + nextY * nextY + nextZ * nextZ);
        double phi = Math.Atan2(nextY, nextX);
        double theta = Math.Asin(nextZ / r);

        r = Math.Pow(r, _power);
        phi *= _power;
        theta *= _power;

        double cosThetaR = Math.Cos(theta) * r;
        nextX = cosThetaR * Math.Cos(phi);
        nextY = cosThetaR * Math.Sin(phi);
        nextZ = r * Math.Sin(theta);

        nextX += _re;
        nextY += _im;
    }
    while ( nextX * nextX +
            nextY * nextY +
            nextZ * nextZ < _bail);

    if (cnt != _iterations + 1)
    {
        return false;
    }
    else
    {
        return true;
    }
}

Хренотень

2011-04-26T11:10:00.026+04:00

Поверхность фрактала "изъедена" бесконечным числом отверстий, проемов, провалов и пр., поэтому его поверхность отражает/рассеивает свет во все стороны одинаково, т. е. его поверхность - матовая. Все эти отражения, преломления и пр. пятна на поверхности всего-лишь украшательства: можно обойтись и без них, но с ними эффектнее.

Для освещения поверхности достаточно Ламберта, но все еще недостаточно чтобы глаза правильно оценили глубину. Перспектива - помогает, но к ней нужно добавить тени. Для большей глубины, не помешает разбавить картину дымкой (distance fog).

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

Дальше →