minsky::anonymous_namespace{wire.cc} Namespace Reference

Functions
vector< pair< float, float > >	allHandleCoords (vector< float > coords)
vector< pair< float, float > >	toCoordPair (vector< float > coords)
vector< vector< float > >	constructTriDiag (int length)
vector< pair< float, float > >	constructTargetVector (int n, const vector< pair< float, float >> &knots)
vector< pair< float, float > >	computeControlPoints (vector< vector< float >> triDiag, const vector< pair< float, float >> &knots, vector< pair< float, float >> target)
bool	segNear (float x0, float y0, float x1, float y1, float x, float y)
float	d2 (float x0, float y0, float x1, float y1)

Function Documentation

allHandleCoords()

vector<pair<float,float> > minsky::anonymous_namespace{wire.cc}::allHandleCoords

(

vector< float >

coords

)

Definition at line 150 of file wire.cc.

Referenced by minsky::Wire::near().

                                                                 {
        
        vector<pair<float,float>> points(coords.size()-1);
        
        for (size_t i = 0; i < points.size(); i++) {
                        if (i%2 == 0) {
                                points[i].first = coords[i];
                                points[i].second = coords[i+1];
                        }
                        else {
                                points[i].first = 0.5*(coords[i-1]+coords[i+1]);
                                points[i].second = 0.5*(coords[i]+coords[i+2]);
                        }
                }                                               
                
   return points;
 }        

Here is the caller graph for this function:

computeControlPoints()

vector<pair<float,float> > minsky::anonymous_namespace{wire.cc}::computeControlPoints	(	vector< vector< float >>	triDiag,
		const vector< pair< float, float >> &	knots,
		vector< pair< float, float >>	target
	)

Thomas' algorithm for solving a matrix equation \(Ac=k\) is based on LU-decomposition into \(LUc=k\) where \(L\) is lower triangular and \(U\) is upper triangular. The matrix equation is solved by setting \(Uc = k'\) and then solving \(Lk' = k\) for \(k'\) first, and subsequently \(Uc\) for \(c\).

There are two steps in this calculation. Step 1 involves simultaneously decomposing \(A = LU\) and solving \(Lk'=k\) for \(k'\) in a forward sweep, with \(Uc=k'\) as result. In step 2, \(Uc=k'\) is solved for \(c\) in a backward sweep. The calculation goes as follows for a small system:

\[ \left(\begin{array}{ccc} b_1 & a_1 & 0 \\ d_1 & b_2 & a_2 \\ 0 & d_2 & b_3 \end{array}\right) \left(\begin{array}{c} c_1 \\ c_2 \\ c_3 \end{array}\right) = \left(\begin{array}{c} k_1 \\ k_2 \\ k_3 \end{array}\right) \]

Forward sweep: row 1:

\( b_1c_1+a_1c_2 = k_1 \)

\( c_1+\frac{c_1}{b_1}c_2 = \frac{k_1}{b_1} \) after dividing through by \(b_1\)

Rewrite row 1 as \( c_1 + \alpha_1c_2 = k'_1\), where \(\alpha_1=\frac{c_1}{b_1}\) and \(k'_1 = \frac{k_1}{b_1}\)

row 2:

\( d_1c_1+b_2c_2+a_2c_3 = k_2 \)
Now eliminate the first term of this equation by subtracting \(d_1 \times\) row 1 from row 2, yielding:

\( (b_2 - d_1\alpha_1)c_2 + a_2c_3 = k_2 - d_1k'_1 \)

Then, dividing through by \((b_2 - d_1\alpha_1)\) and rewriting leads to:

\( c_2 + \alpha_2c_3 = k'_2 \), where \(\alpha_2 = \frac{a_2}{b_2 - d_1\alpha_1}\) and \(k'_2 = \frac{k_2 - d_1k'_1}{b_2 - d_1\alpha_1}\)

row 3:

Finally, subtracting \(d_2 \times\) row 2 from row 3, dividing through by \((b_3-d_2\alpha_2)\), and rewriting, yields:

\( c_3 = k'_3 \), where \(k'_3 = \frac{k_3-d_2k'2}{b_3 - d_2\alpha_2}\)

At this point, the matrix equation has been reduced to

\[ \left(\begin{array}{ccc} 1 & \alpha_1 & 0 \\ 0 & 1 & \alpha_2 \\ 0 & 0 & 1 \end{array}\right) \left(\begin{array}{c} c_1 \\ c_2 \\ c_3 \end{array}\right) = \left(\begin{array}{c} k'_1 \\ k'_2 \\ k'_3 \end{array}\right) \]

In this form, one can solve for the \(c_i\) in terms of \(k'_i\) directly by sweeping backwards through the matrix equation.

(Source: http://www.industrial-maths.com/ms6021_thomas.pdf)

Definition at line 283 of file wire.cc.

Referenced by minsky::Wire::draw().

                                                                                                                                                         {
  
    assert(knots.size() > 2); 
    
    const size_t n = knots.size() - 1;
    
    vector<pair<float,float>> result(2*n); 
 
    // Vector of knots k' after Thomas' algorithm is applied to the initial system Ac = k
    vector<pair<float,float>> newTarget(n); 
    
    // Matrix A' after Thomas' algorithm is applied to the initial system Ac = k
    vector<vector<float>> newTriDiag(n,vector<float>(n));
 
    // forward sweep for control points c_i,0:
    newTriDiag[0][1] = triDiag[0][1]/ triDiag[0][0]; 
 
    newTarget[0].first = target[0].first*(1.0 / triDiag[0][0]);
    newTarget[0].second = target[0].second*(1.0 / triDiag[0][0]);        
    
 
    for (size_t i = 1; i < n-1; i++)
      for (size_t j = 0; j < n; j++)
        if (i == j-1)
          newTriDiag[i][j] = triDiag[i][j] / (triDiag[i][i] - triDiag[i][j-2] * newTriDiag[i-1][j-1]);
 
    for (size_t i = 1; i < n; i++)
      for (size_t j = 0; j < n; j++) {
         if (i == j + 1)
         {
           const float targetScale = 1.0/(triDiag[i][i] - triDiag[i][j] * newTriDiag[i-1][j+1]); 
           newTarget[i].first = (target[i].first-(newTarget[i-1].first*(triDiag[i][j])))*(targetScale);
           newTarget[i].second = (target[i].second-(newTarget[i-1].second*(triDiag[i][j])))*(targetScale);
         }
      }
 
    // backward sweep for control points c_i,0:
    result[n-1].first = newTarget[n-1].first;
    result[n-1].second = newTarget[n-1].second;
    
    for (int i = n-2; i >= 0; i--) 
       for (int j = n-1; j >= 0; j--) {         
          if (i == j-1)
          {
             result[i].first = newTarget[i].first-(newTriDiag[i][j]*result[i+1].first);
             result[i].second = newTarget[i].second-(newTriDiag[i][j]*result[i+1].second);
                  }
    }
 
    // calculate remaining control points c_i,1 directly:
    for (size_t i = 0; i < n-1; i++) {
      result[n+i].first = 2.0*knots[i+1].first-(result[i+1].first);
      result[n+i].second = 2.0*knots[i+1].second-(result[i+1].second);
    }
 
    result[2*n-1].first = 0.5*(knots[n].first+(result[n-1].first));
    result[2*n-1].second = 0.5*(knots[n].second+(result[n-1].second));

    return result;
  }

Here is the caller graph for this function:

constructTargetVector()

vector<pair<float,float> > minsky::anonymous_namespace{wire.cc}::constructTargetVector	(	int	n,
		const vector< pair< float, float >> &	knots
	)

Definition at line 208 of file wire.cc.

Referenced by minsky::Wire::draw().

                                                                                                 {
          
        assert(knots.size() > 2);  
          
    vector<pair<float,float>> result(n); 

    result[0].first = knots[0].first+2.0*knots[1].first;
    result[0].second = knots[0].second+2.0*knots[1].second; 
    
    for (int i = 1; i < n - 1; i++) {
      result[i].first = 2.0*(2.0*knots[i].first+(knots[i+1].first)); 
      result[i].second = 2.0*(2.0*knots[i].second+(knots[i+1].second));  
    }
    
    result[result.size() - 1].first = 8.0*knots[n-1].first+knots[n].first; 
    result[result.size() - 1].second = 8.0*knots[n-1].second+knots[n].second;

    return result;
  }  

Here is the caller graph for this function:

constructTriDiag()

vector<vector<float> > minsky::anonymous_namespace{wire.cc}::constructTriDiag

(

int

length

)

Definition at line 181 of file wire.cc.

Referenced by minsky::Wire::draw().

 {
   vector<vector<float>> result(length,vector<float>(length));
   
   for (int i = 0; i < length; i++)  // rows
     for (int j = 0; j < length; j++) {  // columns
                  
       //construct upper diagonal   
       if (j > 0 && i == j-1 && i < length-1) result[i][j] = 1.0;                               
       //construct main diagonal
       else if (i == j) {
         if (i == 0) result[i][j] = 2.0;
         else if (i < length-1) result[i][j] = 4.0;
         else if (i == length-1) result[i][j] = 7.0;
       }   
       //construct lower diagonal
       else if (i == j+1) {
         if (j < length-2) result[i][j] = 1.0;
         else if (j == length-2) result[i][j] = 2.0;
       }  
       else result[i][j] = 0.0;                                 
     }
  
   return result;
 } 

Here is the caller graph for this function:

d2()

float minsky::anonymous_namespace{wire.cc}::d2 ( float  x0, float  y0, float  x1, float  y1  )

inline

Definition at line 564 of file wire.cc.

References minsky::sqr().

Referenced by minsky::Wire::deleteHandle(), minsky::ScalarEvalOp::deriv(), minsky::Wire::near(), minsky::Wire::nearestHandle(), and segNear().

    {return sqr(x1-x0)+sqr(y1-y0);}

Here is the call graph for this function:

Here is the caller graph for this function:

segNear()

bool minsky::anonymous_namespace{wire.cc}::segNear	(	float	x0,
		float	y0,
		float	x1,
		float	y1,
		float	x,
		float	y
	)

Definition at line 557 of file wire.cc.

References d2(), minsky::sqr(), and MathDAG::sqrt().

Referenced by minsky::Wire::near().

    {
      const float d=sqrt(sqr(x1-x0)+sqr(y1-y0));
      const float d1=sqrt(sqr(x-x0)+sqr(y-y0)), d2=sqrt(sqr(x-x1)+sqr(y-y1));
      return d1+d2<=d+5;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

toCoordPair()

vector<pair<float,float> > minsky::anonymous_namespace{wire.cc}::toCoordPair

(

vector< float >

coords

)

Definition at line 169 of file wire.cc.

Referenced by minsky::Wire::draw().

                                                             {    
   vector<pair<float,float>> points(coords.size()/2);
   
   for (size_t i = 0; i < coords.size(); i++)
     if (i%2 == 0) {
        points[i/2].first = coords[i];
        points[i/2].second = coords[i+1];
     }
   return points;
 }      

Here is the caller graph for this function: