DZone Snippets: poly code

Point Inside a Polygon //JavaScript Function

jonasraoni (Jonas Raoni Soares Silva) — Sun, 30 Mar 2008 16:57:56 GMT

Checks whether a point is inside a polygon.
Adapted from: [http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html]

[UPDATED CODE AND HELP CAN BE FOUND HERE: Point Inside a Polygon]



//+ Jonas Raoni Soares Silva

//@ http://jsfromhell.com/classes/is-point-in-poly [v1.0]



function isPointInPoly(poly, pt){

	for(var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i)

		((poly[i].y <= pt.y && pt.y < poly[j].y) || (poly[j].y <= pt.y && pt.y < poly[i].y))

		&& (pt.x < (poly[j].x - poly[i].x) * (pt.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x)

		&& (c = !c);

	return c;

}

Example

Wave Plotter //Pascal Class

jonasraoni (Jonas Raoni Soares Silva) — Thu, 15 Jun 2006 19:28:29 GMT

A wave plotter component that is able to draw sin, poly and squared lines, I used this in a osciloscope xD

I didn't liked this code, but the draw part (TWaveShape.paint) is looking cool, I used the same "X" coord to draw the 3 kinds of lines :)

I mean:

loop(x){
case waveType of
wtSin: y := lala;
wtPoly: y := lele;
wtSqr: y := lili;
end;
}



unit WavePlotter;



interface



uses

  forms, dialogs, SysUtils, Classes, Controls, Graphics;



const

  PI2 = PI * 2;



type

  TWaveType = ( wtSqr, wtPoly, wtSin );



  TWave = class( TPersistent )

  public

    waveType: TWaveType;

    color: TColor;

    offset: integer;

    frequency, amplitude, volts, interval, gain: extended;



    procedure AssignTo(Dest: TPersistent); override;

  end;



  TWaveShape = class( TGraphicControl )

  protected

    fWaves: TList;

    fBoxSize: integer;

    fLineColor: TColor;



    function getWave(const index: integer): TWave;

    procedure setBoxSize(const Value: integer);



    function getBackgroundColor: TColor;

    procedure setBackgroundColor(const Value: TColor);

    procedure setLineColor(const Value: TColor);



  public

    constructor create( AOwner: TComponent ); override;

    destructor destroy; override;



    procedure clear;

    procedure delete( const index: integer );



    function add: integer;



    property waves[ const index: integer]: TWave read GetWave;



  published

    procedure paint; override;

    property boxSize: integer read fBoxSize write setBoxSize;

    property backgroundColor: TColor read getBackgroundColor write setBackgroundColor;

    property lineColor: TColor read fLineColor write setLineColor;



    //inherited

    //property Canvas;

    property Align;

    property Anchors;

    property Constraints;

    property DragCursor;

    property DragKind;

    property DragMode;

    property Enabled;

    //property Font;

    property ParentColor;

    //property ParentFont;

    property ParentShowHint;

    property PopupMenu;

    property ShowHint;

    property Visible;

    property OnClick;

    property OnContextPopup;

    property OnDblClick;

    property OnDragDrop;

    property OnDragOver;

    property OnEndDock;

    property OnEndDrag;

    property OnMouseDown;

    property OnMouseMove;

    property OnMouseUp;

    property OnStartDock;

    property OnStartDrag;

  end;



implementation



function max( const a, b: integer ): integer;

begin

  if a > b then

    result := a

  else

    result := b;

end;



{ TWaveShape }



function TWaveShape.add: integer;

begin

  result := fWaves.add( TWave.Create );

end;



procedure TWaveShape.clear;

begin

  while fWaves.count > 0 do begin

    TWave( fWaves[0] ).free;

    fWaves.delete( 0 );

  end;

end;



constructor TWaveShape.create(AOwner: TComponent);

begin

  inherited;

  fWaves := TList.create;

  fLineColor := clGray;

  color := clBtnFace;

  fBoxSize := 50;

end;



procedure TWaveShape.delete(const index: integer);

begin

  if ( index > -1 ) and ( index < fWaves.count ) then begin

    TWave( fWaves[index] ).free;

    fWaves.delete( index );

  end;

end;



destructor TWaveShape.destroy;

begin

  fWaves.free;

  inherited;

end;



function TWaveShape.getBackgroundColor: TColor;

begin

  result := color;

end;



function TWaveShape.getWave(const index: integer): TWave;

begin

  result := nil;

  if ( index > -1 ) and ( index < fWaves.count ) then

    result := TWave( fWaves[ index ] );

end;



procedure TWaveShape.paint;

var

  k, x: integer;

  lastX, lastY: array of integer;

  y: extended;

begin

  if not enabled then

    exit;

  canvas.brush.color := color;

  canvas.fillRect( clientRect );



  setLength( lastY, fWaves.count );

  setLength( lastX, fWaves.count );

  for k := 0 to high( lastY ) do begin

    lastY[k] := clientHeight div 2 + waves[k].offset;

    lastX[k] := 0;

  end;



  for x := 0 to max( clientWidth, clientHeight ) do begin

    with canvas do begin

      pen.color := fLineColor;

      pen.width := 1;

      pen.style := psDot;



      if x mod fBoxSize = 0 then begin

        moveTo( 0, x + trunc( frac( clientHeight / 2 / fBoxSize ) * fBoxSize ) );

        lineTo( clientWidth, x + trunc( frac( clientHeight / 2 / fBoxSize ) * fBoxSize ) );



        moveTo( x, 0 );

        lineTo( x, clientHeight );

      end;



      for k := 0 to fWaves.count - 1 do begin

        with waves[k] do begin

          pen.color := color;

          pen.width := 1;

          pen.style := psSolid;



          y := pi*k + PI2 * x * interval / fBoxSize * frequency;



          case waveType of

            wtSin:

              y := sin( y );

            wtPoly: begin

              y := frac( y / PI2 );

              if y <= 0.25 then

                y := y / 0.25

              else if y <= 0.75 then

                y := ( -y + 0.5 ) / 0.25

              else

                y := ( y - 1 ) / 0.25;

            end;

            wtSqr: begin

              if frac( y / PI2 ) <= 0.5 then

                y := 1

              else

                y := -1;

            end;

          end;

          y := ( y * ( fBoxSize / volts ) * amplitude * gain ) + clientHeight / 2 + offset;

          moveTo( lastX[k], lastY[k] );

          lastX[k] := x;

          lastY[k] := trunc( y );

          lineTo( x, lastY[k] );

        end;

      end;

    end;

  end;

end;



procedure TWaveShape.setBackgroundColor(const Value: TColor);

begin

  color := Value;

  Invalidate;

end;



procedure TWaveShape.setBoxSize(const Value: integer);

begin

  fBoxSize := Value;

  invalidate;

end;





procedure TWaveShape.setLineColor(const Value: TColor);

begin

  fLineColor := Value;

  Invalidate;

end;



{ TWave }



procedure TWave.AssignTo(Dest: TPersistent);

begin

  if Dest.ClassType <> TWave then

    inherited;

  with TWave( Dest ) do begin

    waveType := self.waveType;

    color := self.color;

    offset := self.offset;

    frequency := self.frequency;

    amplitude := self.amplitude;

    volts := self.volts;

    interval := self.interval;

    gain := self.gain;

  end;

end;



end.

Closest Polyline Point //Javascript Function

jonasraoni (Jonas Raoni Soares Silva) — Fri, 09 Sep 2005 04:40:06 GMT

Given a dot and a set of lines, it returns the nearest dot over one of the given lines.

[UPDATED CODE AND HELP CAN BE FOUND HERE]



//+ Jonas Raoni Soares Silva

//@ http://jsfromhell.com/math/closest-polyline-point [v1.0]



closestPolyLinePoint = function( px, py, x0, y0, x1, y1, etc, etc, etc ){

	function dotLineLength( x, y, x0, y0, x1, y1, o ){

		function lineLength( x, y, x0, y0 ){

			return Math.sqrt( ( x -= x0 ) * x + ( y -= y0 ) * y );

		}

		if( o && !( o = function( x, y, x0, y0, x1, y1 ){

			if( !( x1 - x0 ) ) return { x: x0, y: y };

			else if( !( y1 - y0 ) ) return { x: x, y: y0 };

			var left, tg = -1 / ( ( y1 - y0 ) / ( x1 - x0 ) );

			return { x: left = ( x1 * ( x * tg - y + y0 ) + x0 * ( x * - tg + y - y1 ) ) / ( tg * ( x1 - x0 ) + y0 - y1 ), y: tg * left - tg * x + y };

		}( x, y, x0, y0, x1, y1 ), o.x >= Math.min( x0, x1 ) && o.x <= Math.max( x0, x1 ) && o.y >= Math.min( y0, y1 ) && o.y <= Math.max( y0, y1 ) ) ){

			var l1 = lineLength( x, y, x0, y0 ), l2 = lineLength( x, y, x1, y1 );

			return l1 > l2 ? l2 : l1;

		}

		else {

			var a = y0 - y1, b = x1 - x0, c = x0 * y1 - y0 * x1;

			return Math.abs( a * x + b * y + c ) / Math.sqrt( a * a + b * b );

		}

	};

	for( var args = [].slice.call( arguments, 0 ), lines = []; args.length > 4; lines[lines.length] = { y1: args.pop(), x1: args.pop(), y0: args.pop(), x0: args.pop() } );

	if( !lines.length )

		return { x: px, y: py };

	var l, i, o = lines[0], lower = { i: 0, l: dotLineLength( px, py, o.x0, o.y0, o.x1, o.y1 ) };

	for( i in lines )

		if( lower.l > ( l = dotLineLength( px, py, ( o = lines[i] ).x0, o.y0, o.x1, o.y1 ) ) )

			lower = { i: i, l: l };

	py = py < Math.min( ( o = lines[lower.i] ).y0, o.y1 ) ? Math.min( o.y0, o.y1 ) : py > Math.max( o.y0, o.y1 ) ? Math.max( o.y0, o.y1 ) : py;

	px = px < Math.min( o.x0, o.x1 ) ? Math.min( o.x0, o.x1 ) : px > Math.max( o.x0, o.x1 ) ? Math.max( o.x0, o.x1 ) : px;

	return Math.abs( o.x0 - o.x1 ) < Math.abs( o.y0 - o.y1 ) ? { x: ( py * ( o.x0 - o.x1 ) - o.x0 * o.y1 + o.y0 * o.x1 ) / ( o.y0 - o.y1 ), y: py }

	: { x: px, y: ( px * ( o.y0 - o.y1 ) - o.y0 * o.x1 + o.x0 * o.y1 ) / ( o.x0 - o.x1 ) };

};