C++ (Cpp) getContour Examples

Example #1

0

Show file

File: Shadows.cpp Project: patriciogonzalezvivo/mesaDelTiempo

void Shadows::handMoved(ofxBlob &_blob){
    
    if ( hands[ _blob.id ] == NULL ){
        hands.erase( _blob.id );
        
        //  If don't have record of this blob probably it's because it's a hole of a blob...
        //  ... so try to find it owner
        //
        ofPolyline contourLine = getContour(_blob);
        int holeOfBlob  = checkIfHole(contourLine);  
        
        if (holeOfBlob >= 0){
            //  If it's a hole it will insert it into the last blobFrame
            //
            hands[holeOfBlob]->insertHole(contourLine);
            //ofLog(OF_LOG_NOTICE,"Adding new frame of hole shadow idº " + ofToString( holeOfBlob ));
        } else {
            ofLog(OF_LOG_NOTICE,"Something goes wrong... I don´t what to do with blob idº " + ofToString( _blob.id ));
        }
        
    } else {
        hands[ _blob.id ]->addFrame(_blob,width,height);
        //ofLog(OF_LOG_NOTICE,"Adding new frame of shadow id " + ofToString( _blob.id ));
    }
}

Example #2

0

Show file

File: Shadows.cpp Project: patriciogonzalezvivo/mesaDelTiempo

void Shadows::handAdded(ofxBlob &_blob){
    
    //  Make a ofPolygone from the _blob
    //
    ofPolyline contourLine = getContour(_blob);
    
    //  Check if it's a hole. If it´s not it will return a -1 if it´s a hole it will
    //  return the nId of the owner
    //
    int holeOfBlob  = checkIfHole(contourLine);  
        
    if (holeOfBlob >= 0){
        
        //  If it´s a hole it will insert it into the last blobFrame
        //
        hands[holeOfBlob]->insertHole(contourLine);
        //ofLog(OF_LOG_NOTICE,"Adding hole to shadow idº " + ofToString( holeOfBlob ));
    } else {
        
        //  If it's not a hole add a new shadow to the map with the first frame
        //
        AnimatedShadow *newShadow = new AnimatedShadow( _blob.id );
        newShadow->addFrame( contourLine, _blob.nFingers );
        hands[ newShadow->getId() ] = newShadow;
        //ofLog(OF_LOG_NOTICE,"Adding shadow idº " + ofToString( newShadow->getId() ));
    }
}

Example #3

0

Show file

File: scribe3D.cpp Project: dmagiccys/pfmabe

void scribe3D (nvMapGL *map, OPTIONS *options, MISC *misc, NV_FLOAT32 *ar, NV_INT32 ncc, NV_INT32 nrr, NV_FLOAT64 xorig, NV_FLOAT64 yorig)
{
  NV_INT32                index_contour, num_points, i, num_interp, bytes, width;
  NV_FLOAT64              dcontour_x[CONTOUR_POINTS], dcontour_y[CONTOUR_POINTS], dcontour_z[CONTOUR_POINTS], dx, dy, cell_diag_length, segment_length;
  NV_FLOAT32              level, half_gridx, half_gridy, *contour_x, *contour_y, x[2], y[2], z[2], *xyz_x, *xyz_y, *xyz_z;


  void contourMinMax (NV_FLOAT32, NV_FLOAT32);
  void contourEmphasis (NV_INT32);
  void contourMaxDensity (NV_INT32);
  void contourMaxPoints (NV_INT32);
  void contourLevels (NV_INT32 numLevels, NV_FLOAT32 *);
  NV_INT32 initContour (NV_FLOAT32, NV_INT32, NV_INT32, NV_FLOAT32 *);
  NV_INT32 getContour (NV_FLOAT32 *, NV_INT32 *, NV_INT32 *, NV_FLOAT32 *, NV_FLOAT32 *);


  //  Check the smoothing factor range and get the number of interpolation 
  //  points per unsmoothed contour segment

  if (options->smoothing_factor < 0) options->smoothing_factor = 0;
  if (options->smoothing_factor > 10) options->smoothing_factor = 10;


  dcontour_x[0] = xorig + (misc->x_grid_size * ncc) * 0.5;
  dcontour_y[0] = yorig + (misc->y_grid_size * nrr) * 0.5;
  dcontour_x[1] = dcontour_x[0] + misc->x_grid_size;
  dcontour_y[1] = dcontour_y[0] + misc->y_grid_size;

  map->map_to_screen (2, dcontour_x, dcontour_y, dcontour_z, x, y, z);

  dx = x[1] - x[0];
  dy = y[1] - y[0];

  cell_diag_length = sqrt (pow (dx, 2) + pow (dy, 2));

  segment_length = DEFAULT_SEGMENT_LENGTH / options->smoothing_factor;

  if (cell_diag_length > segment_length)
    {
      num_interp = (NV_INT32) ((cell_diag_length / segment_length) + 0.5);
    }
  else
    {
      num_interp = 1;
    }


  /* allocate memory for contour arrays */

  if (options->smoothing_factor > 0)
    {
      bytes = (((num_interp * (CONTOUR_POINTS - 1)) + 1) * sizeof (NV_FLOAT64));
    }
  else
    {
      bytes = (CONTOUR_POINTS * sizeof (NV_FLOAT64));
    }

  contour_x = (NV_FLOAT32 *) malloc (bytes / 2);
  contour_y = (NV_FLOAT32 *) malloc (bytes / 2);
  xyz_x = (NV_FLOAT32 *) malloc (bytes);
  xyz_y = (NV_FLOAT32 *) malloc (bytes);
  if ((xyz_z = (NV_FLOAT32 *) malloc (bytes)) == NULL)
    {
      perror (__FILE__);
      exit (-1);
    }


  //  Set the min and max contours, the index contour interval, the
  //  maximum contour density, and the number of points to be returned
  //  by the package.

  contourMinMax (misc->min_z * options->z_factor + options->z_offset, misc->max_z * options->z_factor + options->z_offset);
  contourMaxDensity (misc->maxd);
  contourMaxPoints (CONTOUR_POINTS);


  //  If the contour interval is set to 0.0 use the user defined levels.

  if (misc->abe_share->cint == 0.0) contourLevels (misc->abe_share->num_levels, misc->abe_share->contour_levels);


  //  Pass the grid array (arranged 1D) to the contouring package.

  initContour (misc->abe_share->cint, nrr, ncc, ar);


  //  Compute half of a grid cell in degrees.

  half_gridx = misc->x_grid_size * 0.5;
  half_gridy = misc->y_grid_size * 0.5;


  //  Get the contours from the package until all are drawn.

  while (getContour (&level, &index_contour, &num_points, contour_x, contour_y))
    {
      //  Convert from grid points (returned contours) to position.
                    
      for (i = 0 ; i < num_points ; i++)
        {
          dcontour_x[i] = xorig + (contour_x[i] * misc->x_grid_size) + half_gridx;
          dcontour_y[i] = yorig + (contour_y[i] * misc->y_grid_size) + half_gridy;
          dcontour_z[i] = -level;
        }


      //  Convert from position to pixels.

      map->map_to_screen (num_points, dcontour_x, dcontour_y, dcontour_z, xyz_x, xyz_y, xyz_z);


      //  smooth out the contour (don't do this sooner for the sake of efficiency -- smooth in xy plot space)

      if (options->smoothing_factor > 0) smooth_contour (num_interp, &num_points, xyz_x, xyz_y);


      //  If this is the zero contour, thicken the line.

      width = options->contour_width;
      if (level == 0.0)
        {
          switch (width)
            {
            case 1:
              width = 3;
              break;

            case 2:
              width = 4;
              break;

            case 3:
              width = 5;
              break;
            }
        }


      //  Draw the contours.
            
      for (i = 0 ; i < num_points ; i++) map->setLines (xyz_x[i], xyz_y[i], xyz_z[i], options->contour_color, width, Qt::SolidLine, i, NVFalse);


      //  Check the event queue to see if the user wants to interrupt the contouring.

      if (qApp->hasPendingEvents ())
        {
          qApp->processEvents ();
          if (misc->drawing_canceled) break;
        }
    }

  free (contour_x);
  free (contour_y);
  free (xyz_x);
  free (xyz_y);
  free (xyz_z);


  map->setLines (0.0, 0.0, 0.0, Qt::black, 1, Qt::SolidLine, 0, NVTrue);


  map->flush ();
}

Example #4

0

Show file