FixpointShapes - graphical primitives based on fixpoint arithmetics

Features:

• Template-based (header-only) C++ library - better performance.
• The coordinate calculations use a fixpoint arithmetics (that's the reason for the name). The number of fixed point fraction (precision) is parameterizable (the default 16 bits is generally enough for the most cases).
• The library implements the most usual graphical/geometrical primitives, like lines, polylines, polygons, circles, arcs, texts, etc.
• The algorithms and the actual activities are always independent: from the point of view of the former the latter is always abstract. The concrete activity is always programmed through functors - similarly to the STL, where the algorithms are independent from the actual activity (like sort or for_each).
• There are several predefined drawing functors that allows the usage of different styles (like line style, filling styles, etc) and are abstract, too (they just build a layer above the real geometrical primitives).
  This is a good example for chaining the abstarct layers in succession (and therby creating more and more complex structures, according to the current needs and with high parameterization).
• Text drawing with several fonts and other properties, the texts can be rotated, too.
• Default transformations for planar operations (magnification, ratio change, multiplication/repeating the operations, transformation to a general rectangle).
• Default functors to the actual drawing: onto a HDC or an IMAGEDATA.
  (Disclaimer: drawing onto an HDC in pixel-by-pixel mode is slow! I actually use it only for testing purposes. The IMAGEDATA is perfect for the flicker-free double-buffering).

Applications that use the library:

• SImEditor: a graphical editor to create and edit pixel graphics with predefined and parameterizable objects (like lines with arrows, etc).
• ECalc: the GUI version and extension of the Eval library (the FixpointShapes is used to show the expressions in a graphical form).
• FOuCUS: the algorithms are used to apply calculations to specific parts of the images.
• Graphical components: these (C++ Builder) components use the library to draw the contents (for example with filling styles).

Main application areas:

• Graphical programs that have to be ablo to draw complex things. The best example for this is the SImEditor.
• Image processing: as the geometric calculations are completely independent from the activity (the functors), the algorithms can easily be used the apply calculations for specific image areas or make calculations on a geometric dataset, where the data has been collected from an image.
  Things like these can be for example creating a section along a line (the line points are collected with the ScanLinePoints function), or creating the circle points for a Hough-transformational circle finder.

Examples:

• ScanLinePoints(1, 1, 34, 16, TSetDCPixel(hDC, clBlack, 5));

  

  The pixel zooming is the feature of the (pixel drawing) functor (the last parameter). The algorithm simply forwards the pixel coordinates to the functor which draws the zoomed pixels.

• ScanLinePoints(10, 10, 100, 80, TSpray<TSetDCPixel>(TSetDCPixel(Canvas->Handle), 10, 50));

  

  This sprays random pixels along a line, within the range and with the probability of the TSpray object parameters.

• ScanCirclePoints(100, 100, 50, Pen(ptHorz, TSetDCPixel(Canvas->Handle), 5));

  

  This draws a circle with a (horizontally elongated) brush-like pen.

  The definition for this pen functor is here. This is a good example of functors, too.

• // polygon/line coordinates FIXPOINT p[] = { { 10, 10 }, { 84, 18 }, { 100, 82 }, { 55, 100 }, { 20, 50 }, { 50, 40 }, }; const int pn = sizeof(p) / sizeof(p[0]); TSetDCPixel sdc(Canvas->Handle, clBlack), // create the foreground functor bkdc(Canvas->Handle, clRed); // create the background functor // apply the functors to the polygon points ScanPolygonPoints(p, pn, TDenseVisitor(0, sdc, bkdc)); sdc.Color = clGreen; // set new values sdc.Size = 3; // draw the outline of the polygon ScanPolylinePoints(p, pn, sdc);

  

  First we fill a polygon with a specific filling style (solid red background and black points at even distances from each other).
  Then we draw a line around the polygon, with other color and pixel size (line width). The polyline is not closed, as we didn't add the first point at the last position.

• FIXPOINT *p = ... Polyline(Canvas->Handle, p, 5); ScanPolylinePointsT(p, 5, TWideDashLine(sdp, sdp, 10, 35, 10));

  

  First we draw a single line with the given points.
  The second call draws a more complex structure: rectangles with given length and width along the line.
  The WideDash functor works so that it calculates the perpendicular points when a given length is reached along the line (the starting and ending postion of the rect), and then uses the ScanPolyline function to draw the actual points.

• TPointCollector pc; ScanLinePoints(0, 0, 120, 71, DFWrapper(pc)); // the DFWrapper makes the real functor available by reference (to store the results in the original object) // go through the collected points for (vector::iterator pi = pc.begin(); pi != pc.end(); ++pi) ...

  The same method can be used for the other geomteric functions (ScanPolylinePoints, ScanCirclePoints, ScanEllipsePoints, etc).