Photometric stereo 2009-06-05

To do: draw a needle map

ref. Washington University's source code:  

Washington University's source code:

 PsmView.cpp

////////////////////////////////////////////////////////
// PsmView::drawNeedles(): use normal information to
//   draw a needle map.
//
void
PsmView::drawNeedles() const
{
    const int vectorStep = (int)theUI->needleSpacing->value();
    const int vectorSize = (int)(vectorStep * .9);

    glColor3ub(255,255,255);
    glPointSize(2);

    const NormalImage *normals = theApp->getNormals();

    int width = normals->Shape().width;
    int height = normals->Shape().height;

    for(int i=0;i<width;i+=vectorStep)
 for(int j=0;j<height;j+=vectorStep)
 {
     Vec3f vec = normals->Pixel(i,j,0);
     if (vec.z != vec.z) continue;   // NaN
     if ((vec.x == 0) && (vec.y == 0) && (vec.z == 0))
  continue; // empty

     vec = vec.normalized()*(float)vectorSize;
     vec.z = 0;

     glBegin(GL_LINES);
     glVertex2i(i,j);
     glVertex2f(i + vec.x, j + vec.y);
     glEnd(); 

     glBegin(GL_POINTS);
     glVertex2f(i + vec.x, j + vec.y);
     glEnd(); 
      }
}

 

///////////////////////////////////////////////////////////////////////////
// PsmApp::computeShadingNormals:  given newly loaded or computed
// depths, compute the "shading normals" for this depth buffer, so
// that surface renderings reflect the normals of an integrable surface
//
bool
PsmApp::computeShadingNormals()
{
    assert(depths);

    // check recomputed normals buffer, reallocate if necessary,
    // and recompute
    if (shadingNormals && (shadingNormals->Shape() != depths->Shape()))
    {
 delete shadingNormals;
 shadingNormals = 0;
    }

    int width = depths->Shape().width;
    int height = depths->Shape().height;

    if (!shadingNormals)
 shadingNormals = new NormalImage(width,height,1);

    for (int y = 0; y<height; y++)
 for (int x = 0; x<width; x++)
 {
     Vec3f &n = shadingNormals->Pixel(x,y,0);
     if (mask && !mask->Pixel(x,y,0))
  n = Vec3f(0,0,1);
     else
     {
  Vec3f dx = Vec3f(1,0,depths->Pixel(x+1,y,0) - depths->Pixel(x,y,0));
  Vec3f dy = Vec3f(0,1,depths->Pixel(x,y+1,0) - depths->Pixel(x,y,0));
  n = dx.cross(dy).normalized();
     }
 }

    return true;
}

    Vec3         cross (const Vec3 &v) const
 { return Vec3 (y * v.z - z * v.y,
         z * v.x - x * v.z,
         x * v.y - y * v.x); }

 

http://opencv.willowgarage.com/wiki/CxCore#CurvesandShapes

Line

Draws a line segment connecting two points

void cvLine( CvArr* img, CvPoint pt1, CvPoint pt2, CvScalar color,
             int thickness=1, int line_type=8, int shift=0 );

img

The image.

pt1

First point of the line segment.

pt2

Second point of the line segment.

color

Line color.

thickness

Line thickness.

line_type

Type of the line:

• 8 (or omitted) - 8-connected line.

• 4 - 4-connected line.

• CV_AA - antialiased line.

shift

Number of fractional bits in the point coordinates.

The function cvLine draws the line segment between pt1 and pt2 points in the image. The line is clipped by the image or ROI rectangle. For non-antialiased lines with integer coordinates the 8-connected or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings. Antialiased lines are drawn using Gaussian filtering. To specify the line color, the user may use the macro CV_RGB( r, g, b ).