stereoRecon.h - Hosted on DriveHQ Cloud IT Platform

Up
Upload
Download
Share
Publish
New Folder
New File
Copy
Cut
Delete
Paste
Rate
Upgrade
- Rotate
- Effect
- Edit
- Slide
- History
//=============================================================================
#ifndef STEREORECON_H
#define STEREORECON_H

#include "pointSet.h"
#include "matrix.h"
#include "subWindow.h"

class stereoMovieRecon;

class stereoRecon
{
public:
  // specifying the inmage size is not "necessary" but it will help in
  // solving the numerical system
  stereoRecon( const pointMatches2D &pntList,
	       int imgSizeX=100, int imgSizeY=100 );
  stereoRecon( const vector<subWindowListAnim> &features,
	       int frame1, int frame2,
	       int imgSizeX=100, int imgSizeY=100 );
  stereoRecon( const stereoRecon &src, bool invert=false );


public:
  bool epipolarRecon( const pointMatches2D pntList,
		      int imgSizeX=100, int imgSizeY=100 );
  bool epipolarRecon( const vector<subWindowListAnim> &features,
		      int frame1, int frame2,
		      int imgSizeX=100, int imgSizeY=100 );
  void calcFpAndEpipoles( const matrix3x3 &F,
			  matrix3x3 &Fp, point3D &e1, point3D &e2 );
  void computeP( const matrix3x3 F, const point3D &e1, const point3D &e2,
		 matrix3x4 &P1, matrix3x4 &P2 );
  matrix3x3 estimateF( pointMatches2D pntList );
  const matrix3x3 &getF() const { return F_; }
  const matrix3x3 &getFp() const { return Fp_; }
  const matrix3x4 &getLeftP() const { return leftP_; }
  const matrix3x4 &getRightP() const { return rightP_; }
  int numIdealPntMatches() const { return idealReconPnts_.size(); }
  point2D getReconPntRight(int i) const;
  point2D getReconPntLeft(int i) const;
  int numMeasuredPntMatches() const { return measuredPnts_.size(); }
  point2D getMeasuredPntRight(int i) const;
  point2D getMeasuredPntLeft(int i) const;
  point3D getEpipolarLineRight( int i ) const;
  point3D getEpipolarLineLeft( int i ) const;
  point3D getLeftE() const;
  point3D getRightE() const;
  bool isValid() const { return valid_; }

  float avgPntReconError() const { return avgPntReconError_; }
  float FReconError() const { return avgFReconError_; }

  const pointMatches2D &getIdealPntMatches() { return idealReconPnts_; }

  bool triangulate( const point2D &leftPnt, const point2D &rightPnt,
		    point3D &scenePnt);

friend class stereoMovieRecon;
private:
  float origImgSizeX_, origImgSizeY_;
  matrix3x3 F_;
  matrix3x3 Fp_;
  matrix3x4 leftP_, rightP_;
  point3D e1_, e2_;
  pointMatches2D idealReconPnts_;
  pointMatches2D measuredPnts_;
  float avgPntReconError_;
  float avgFReconError_;
  bool valid_;
};


class stereoMovieRecon
{
public:
  stereoMovieRecon( const vector<subWindowListAnim> &features,
		   int width, int height, int length );
  ~stereoMovieRecon();

  stereoRecon *getStereoRecon( int i, int j ) { return F_[i][j]; }
  

private:
  void calcDirectFs( const vector<subWindowListAnim> &features );
  void extrapolateFs();
  stereoRecon *calcSingleF( int i, int j, int k, int l );
  point3D pointTransfer3View( const stereoRecon &F31,
			      const stereoRecon &F32,
			      const stereoRecon &F12,
			      const point3D pntInRef12 );
  point3D pointTransfer3View( const stereoRecon &F31,
			      const stereoRecon &F32,
			      const point3D &pnt1,
			      const point3D &pnt2 );
  point3D pointTransfer3View( const stereoRecon &F31,
			      const stereoRecon &F32,
			      const point2D &pnt1,
			      const point2D &pnt2 );
  
private:
  stereoRecon **Fbuf_;
  stereoRecon ***F_;
  int length_, width_, height_;
};


inline
stereoRecon::stereoRecon( const pointMatches2D &pntList,
			  int imgSizeX, int imgSizeY )
  : e1_(0,0,0), e2_(0,0,0)
{
  valid_=epipolarRecon( pntList, imgSizeX, imgSizeY );
}

inline
stereoRecon::stereoRecon( const vector<subWindowListAnim> &features,
			  int frame1, int frame2,
			  int imgSizeX, int imgSizeY )
  : e1_(0,0,0), e2_(0,0,0)
{
  valid_=epipolarRecon( features, frame1, frame2, imgSizeX, imgSizeY );
}

inline
stereoMovieRecon::stereoMovieRecon( const vector<subWindowListAnim> &features,
				    int width, int height, int length )
  :length_(length), width_(width), height_(height)
{
  Fbuf_ = (stereoRecon**)malloc( length*length*sizeof(stereoRecon*) );
  for ( int i=length*length-1; i>=0; i-- )
    Fbuf_[i] = NULL;
  F_ = (stereoRecon***)malloc( length*sizeof(stereoRecon**) );
  for ( i=length-1; i>=0; i-- )
    F_[i] = &Fbuf_[i*length];

  calcDirectFs( features );
  //extrapolateFs();
}

inline
stereoMovieRecon::~stereoMovieRecon()
{
  free( Fbuf_ );
  free( F_ );
}

#endif // STEREORECON_H
stereoRecon.h
Page URL
File URL
Prev 40/50 Next
Download ( 4 KB )
Leading Cloud Surveillance, recording and storage service. IP camera remote viewing, live streaming, broadcasting
Leading Enterprise Cloud IT Service. Cloud File Server, Drive Mapping, FTP Hosting, Online Storage
Note: The DriveHQ service banners will NOT be displayed if the file owner is a paid member.
Comments
Total ratings: 0 Average rating:
Not Rated
Would you like to comment?

Join DriveHQ for a free account, or Logon if you are already a member.