const state_base* old_state=curr_state;
void *old_context=state_context;
- // Clear out the current state and it's state_context
+ // Clear out the current state and its state_context
curr_state=0;state_context=0;
// Leave the state
/*
If pict is invalid (NULL), then we are done compressing frames and we are trying to get
- the buffer cleared out (or if it's already in the right format) so no transofrm necessary
+ the buffer cleared out (or if it's already in the right format) so no transform necessary
*/
if ( pict )
{
{
#if 1
- //with a starting vertex, find the only vertex that has all other vertices on it's right
+ //with a starting vertex, find the only vertex that has all other vertices on its right
int i,j;
int first,cur,last;
return false;
}
-//Find the closest point on the curve to a point (and return it's distance, and time value)
+//Find the closest point on the curve to a point (and return its distance, and time value)
Real find_closest(const etl::bezier<Point> &curve, const Point &point, float step, Real *closest, float *t);
//----------- Rectangle helper functions ---------------
const Real cn[4] = {a,b,c,d};
Real p,dp,newt,oldpmag=FLT_MAX;
- //eval cubic eqn and it's derivative
+ //eval cubic eqn and its derivative
for(;;)
{
p = cn[0]*t + cn[1];
/* Given the degree m and the m+1 complex coefficients a[0..m] of the polynomial sum(i=0,m){a[i]x^i},
and given a complex value x, this routine improves x by laguerre's method until it converges,
-within the acheivable roundoff limit, to a root of teh given polynomial. The number of iterations taken
-is returned as its.
+within the achievable roundoff limit, to a root of the given polynomial. The number of iterations taken
+is returned as `its'.
*/
void laguer(Complex a[], int m, Complex *x, int *its)
{
d = f = Complex(0,0); //clear variables for use
abx = abs(*x); //the magnitude of the current root
- //Efficent computation of the polynomial and it's first 2 derivatives
+ //Efficent computation of the polynomial and its first 2 derivatives
for(j = m-1; j >= 0; --j)
{
f = (*x)*f + d;
#define EPS 2.0e-6
#define MAXM 100 //a small number, and maximum anticipated value of m..
-/* Given the degree m ad the m+1 complex coefficients a[0..m] of the polynomial a0 + a1*x +...+ an*x^n
+/* Given the degree m and the m+1 complex coefficients a[0..m] of the polynomial a0 + a1*x +...+ an*x^n
the routine successively calls laguer and finds all m complex roots in roots[1..m].
The boolean variable polish should be input as true (1) if polishing (also by Laguerre's Method)
- is desired, false (0) if teh roots will be subsequently polished by other means.
+ is desired, false (0) if the roots will be subsequently polished by other means.
*/
void RootFinder::find_all_roots(bool polish)
{
if(entry_iter->state==true)
{
if(entry_iter->priority)
+ {
+ printf("begin priority is %d\n", entry_iter->priority);
begin_sequence+=strprintf("p%d ",entry_iter->priority);
+ }
begin_sequence+=entry_iter->time.get_string(fps)+", ";
}
else
{
if(entry_iter->priority)
+ {
+ printf("end priority is %d\n", entry_iter->priority);
end_sequence+=strprintf("p%d ",entry_iter->priority);
+ }
end_sequence+=entry_iter->time.get_string(fps)+", ";
}
ValueBase value=layer->get_param(iter->get_name());
if(!value.is_valid())
{
- error("Layer doesn't know it's own vocabulary -- "+iter->get_name());
+ error("Layer doesn't know its own vocabulary -- "+iter->get_name());
continue;
}
//! Sets the RendDesc for the Target to \a desc.
/*! If there are any parts of \a desc that the render target
** is not capable of doing, the render target will adjust
- ** \a desc to fit it's needs.
+ ** \a desc to fit its needs.
*/
virtual bool set_rend_desc(RendDesc *d) { desc=*d; return true; }
// If the canvas is really big, zoom out so that we can fit it all in the window
/*! \todo In other words, this is a zoom-to-fit, and should be
- ** in it's own function.
+ ** in its own function.
*/
int w=get_canvas()->rend_desc().get_w()+70;
int h=get_canvas()->rend_desc().get_h()+70;
//search around this area to get the right one
- //get first valid line and it's position in pixel space
+ //get first valid line and its position in pixel space
double time = 0;
double pixel = 0;
double subr = scale / subdiv;
- //get it's position inside...
+ //get its position inside...
time = ceil(start/subr)*subr - start;
pixel = time*dpdt;
j2 = j++;
for(; j != end; j2 = j++)
{
- //if this curve has invalid error (in j) then retesselate it's work points (requires reparametrization, etc.)
+ //if this curve has invalid error (in j) then retesselate its work points (requires reparametrization, etc.)
if(j->error < 0)
{
//get the stepsize etc. for the number of points in here