smash-intersector.cpp

Go to the documentation of this file.

/*
 * Diffeomorphism-based intersector: given two curves
 *  M(t)=(x(t),y(t)) and N(u)=(X(u),Y(u))
 * and supposing M is a graph over the x-axis, we compute y(x) and solve
 *  Y(u) - y(X(u)) = 0
 * to get the intersections of the two curves...
 *
 * Notice the result can be far from intuitive because of the choice we have
 * to make to consider a curve as a graph over x or y. For instance the two
 * branches of xy=eps are never close from this point of view (!)...
 *
 * Authors:
 *      J.-F. Barraud    <jfbarraud at gmail.com>
 * Copyright 2010  authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 */
 
 
#include <2geom/d2.h>
#include <2geom/sbasis.h>
#include <2geom/path.h>
#include <2geom/bezier-to-sbasis.h>
#include <2geom/sbasis-geometric.h>
#include <toys/path-cairo.h>
#include <toys/toy-framework-2.h>
 
#include <cstdlib>
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
 
#include <2geom/orphan-code/intersection-by-smashing.h>
#include "../2geom/orphan-code/intersection-by-smashing.cpp"
 
using namespace Geom;
 
#define VERBOSE 0
 
static double exp_rescale(double x){ return ::pow(10, x);}
std::string exp_formatter(double x){ return default_formatter(exp_rescale(x));}
 
 
 
#if 0
//useless here;
Piecewise<D2<SBasis> > linearizeCusps( D2<SBasis> f, double tol){
    D2<SBasis> df = derivative( f );
    std::vector<Interval> xdoms = level_set( df[X], 0., tol);
    std::vector<Interval> ydoms = level_set( df[Y], 0., tol);
    std::vector<Interval> doms;
    //TODO: use order!!
    for ( unsigned i=0; i<xdoms.size(); i++ ){
        OptInterval inter = xdoms[i];
        for ( unsigned j=0; j<ydoms.size(); j++ ){
            inter &= ydoms[j];
        }
        if (inter) {
            doms.push_back( *inter );
        }
    }
    Piecewise<D2<SBasis> > result;
    if (doms.size() == 0 ) return Piecewise<D2<SBasis> >(f);
    if (doms[0].min() > 0 ){
        result.cuts.push_back( 0 );
        result.cuts.push_back( doms[0].min() );
        result.segs.push_back( portion( f, Interval( 0, doms[0].min() ) ) );
    }
    for ( unsigned i=0; i<doms.size(); i++ ){
        Point a = result.segs.back().at1();
        Point b = f.valueAt( doms[i].middle() );
        Point c = f.valueAt( doms[i].max() );
        result.cuts.push_back( doms[i].middle() );
        result.segs.push_back( D2<SBasis>( Linear( a[X], b[X] ), Linear( a[Y], b[Y] ) ) );
        result.cuts.push_back( doms[i].max() );
        result.segs.push_back( D2<SBasis>( Linear( b[X], c[X] ), Linear( b[Y], c[Y] ) ) );
        double t = ( i+1 == doms.size() )? 1 : doms[i+1].min();
        result.cuts.push_back( t );
        result.segs.push_back( portion( f, Interval( doms[i].max(), t ) ) );
    }
    return result;
}
#endif
 
#if 0
/* Computes the intersection of two sets given as (ordered) union intervals.
 */
std::vector<Interval> intersect( std::vector<Interval> const &a, std::vector<Interval> const &b){
    std::vector<Interval> result;
    //TODO: use order!
    for (unsigned i=0; i < a.size(); i++){
        for (unsigned j=0; j < b.size(); j++){
            OptInterval c( a[i] );
            c &= b[j];
            if ( c ) {
                result.push_back( *c );
            }
        }
    }
    return result;
}
 
/* Computes the top and bottom boundaries of the L_\infty neighborhood
 * of a curve. The curve is supposed to be a graph over the x-axis.
 */
void computeLinfinityNeighborhood( D2<SBasis > const &f, double tol, D2<Piecewise<SBasis> > &topside, D2<Piecewise<SBasis> > &botside ){
    double signx = ( f[X].at0() > f[X].at1() )? -1 : 1;
    double signy = ( f[Y].at0() > f[Y].at1() )? -1 : 1;
 
    Piecewise<D2<SBasis> > top, bot;
    top = Piecewise<D2<SBasis> > (f);
    top.cuts.insert( top.cuts.end(), 2);
    top.segs.insert( top.segs.end(), D2<SBasis>(Linear( f[X].at1(), f[X].at1()+2*tol*signx),
                                                Linear( f[Y].at1() )) );
    bot = Piecewise<D2<SBasis> >(f);
    bot.cuts.insert( bot.cuts.begin(), - 1 );
    bot.segs.insert( bot.segs.begin(), D2<SBasis>(Linear( f[X].at0()-2*tol*signx, f[X].at0()),
                                                  Linear( f[Y].at0() )) );
    top += Point(-tol*signx,  tol);
    bot += Point( tol*signx, -tol);
 
    if ( signy < 0 ){
        swap( top, bot );
        top += Point( 0,  2*tol);
        bot += Point( 0, -2*tol);
    }
    topside = make_cuts_independent(top);
    botside = make_cuts_independent(bot);
}
 
 
/*Compute top and bottom boundaries of the L^infty nbhd of the graph of a *monotonic* function f.
 * if f is increasing, it is given by [f(t-tol)-tol, f(t+tol)+tol].
 * if not, it is [f(t+tol)-tol, f(t-tol)+tol].
 */
void computeLinfinityNeighborhood( Piecewise<SBasis> const &f, double tol, Piecewise<SBasis> &top, Piecewise<SBasis> &bot){
    top = f + tol;
    top.offsetDomain( - tol );
    top.cuts.insert( top.cuts.end(), f.domain().max() + tol);
    top.segs.insert( top.segs.end(), SBasis(Linear( f.lastValue() + tol )) );
 
    bot = f - tol;
    bot.offsetDomain( tol );
    bot.cuts.insert( bot.cuts.begin(), f.domain().min() - tol);
    bot.segs.insert( bot.segs.begin(), SBasis(Linear( f.firstValue() - tol )) );
 
    if ( f.firstValue() > f.lastValue() ){
    swap( top, bot );
    top += 2*tol;
    bot -= 2*tol;
    }
}
 
std::vector<Interval> level_set( D2<SBasis> const &f, Rect region){
    std::vector<Interval> x_in_reg = level_set( f[X], region[X] );
    std::vector<Interval> y_in_reg = level_set( f[Y], region[Y] );
    std::vector<Interval> result = intersect ( x_in_reg, y_in_reg );
    return result;
}
 
void prolongateByConstants( Piecewise<SBasis> &f, double paddle_width ){
    if ( f.size() == 0 ) return; //do we have a covention about the domain of empty pwsb?
    f.cuts.insert( f.cuts.begin(), f.cuts.front() - paddle_width );
    f.segs.insert( f.segs.begin(), SBasis( f.segs.front().at0() ) );
    f.cuts.insert( f.cuts.end(), f.cuts.back() + paddle_width );
    f.segs.insert( f.segs.end(), SBasis( f.segs.back().at1() ) );
}
 
 
 
/* Returns the intervals over which the curve keeps its slope
 * in one of the 8 sectors delimited by x=0, y=0, y=x, y=-x.
 * WARNING: both curves are supposed to be a graphs over x or y axis,
 *     and the smaller the slopes the better (typically <=45°).
 */
std::vector<std::pair<Interval, Interval> > smash_intersect( D2<SBasis> const &a, D2<SBasis> const &b,
            double tol, cairo_t *cr , bool draw_more_stuff=false ){
 
    std::vector<std::pair<Interval, Interval> > res;
 
    // a and b or X and Y may have to be exchanged, so make local copies.
    D2<SBasis> aa = a;
    D2<SBasis> bb = b;
    bool swapresult = false;
    bool swapcoord = false;//debug only!
 
    if ( draw_more_stuff ){
        cairo_set_line_width (cr, 3);
        cairo_set_source_rgba(cr, .5, .9, .7, 1 );
        cairo_d2_sb(cr, aa);
        cairo_d2_sb(cr, bb);
        cairo_stroke(cr);
    }
 
#if 1
    //if the (enlarged) bounding boxes don't intersect, stop.
    if ( !draw_more_stuff ){
        OptRect abounds = bounds_fast( a );
        OptRect bbounds = bounds_fast( b );
        if ( !abounds || !bbounds ) return res;
        abounds->expandBy(tol);
        if ( !(abounds->intersects(*bbounds))){
            return res;
        }
    }
#endif
 
    //Choose the best curve to be re-parametrized by x or y values.
    OptRect dabounds = bounds_exact(derivative(a));
    OptRect dbbounds = bounds_exact(derivative(b));
    if  ( dbbounds->min().length() > dabounds->min().length() ){
        aa=b;
        bb=a;
        swap( dabounds, dbbounds );
        swapresult = true;
    }
 
    //Choose the best coordinate to use as new parameter
    double dxmin = std::min( abs((*dabounds)[X].max()), abs((*dabounds)[X].min()) );
    double dymin = std::min( abs((*dabounds)[Y].max()), abs((*dabounds)[Y].min()) );
    if ( (*dabounds)[X].max()*(*dabounds)[X].min() < 0 ) dxmin=0;
    if ( (*dabounds)[Y].max()*(*dabounds)[Y].min() < 0 ) dymin=0;
    assert (dxmin>=0 && dymin>=0);
 
    if (dxmin < dymin) {
        aa = D2<SBasis>( aa[Y], aa[X] );
        bb = D2<SBasis>( bb[Y], bb[X] );
        swapcoord = true;
    }
 
    //re-parametrize aa by the value of x.
    Interval x_range_strict( aa[X].at0(), aa[X].at1() );
    Piecewise<SBasis> y_of_x = pw_compose_inverse(aa[Y],aa[X], 2, 1e-5);
 
    //Compute top and bottom boundaries of the L^infty nbhd of aa.
    Piecewise<SBasis> top_ay, bot_ay;
    computeLinfinityNeighborhood( y_of_x, tol, top_ay, bot_ay);
 
    Interval ax_range = top_ay.domain();//i.e. aa[X] domain ewpanded by tol.
 
    if ( draw_more_stuff ){
        Piecewise<SBasis> dbg_x( SBasis( Linear( top_ay.domain().min(), top_ay.domain().max() ) ) );
        dbg_x.setDomain( top_ay.domain() );
        D2<Piecewise<SBasis> > dbg_side ( Piecewise<SBasis>( SBasis( Linear(   0    ) ) ),
                                          Piecewise<SBasis>( SBasis( Linear( 0, 2*tol) ) ) );
 
        D2<Piecewise<SBasis> > dbg_rgn;
        unsigned h = ( swapcoord ) ? Y : X;
        dbg_rgn[h].concat ( dbg_x );
        dbg_rgn[h].concat ( dbg_side[X] + dbg_x.lastValue() );
        dbg_rgn[h].concat ( reverse(dbg_x) );
        dbg_rgn[h].concat ( dbg_side[X] + dbg_x.firstValue() );
 
        dbg_rgn[1-h].concat ( bot_ay );
        dbg_rgn[1-h].concat ( dbg_side[Y] + bot_ay.lastValue() );
        dbg_rgn[1-h].concat ( reverse(top_ay) );
        dbg_rgn[1-h].concat ( reverse( dbg_side[Y] ) + bot_ay.firstValue() );
 
        cairo_set_line_width (cr, 1.);
        cairo_set_source_rgba(cr, 0., 1., 0., .75 );
        cairo_d2_pw_sb(cr, dbg_rgn );
        cairo_stroke(cr);
 
        D2<SBasis> bbb = bb;
        if ( swapcoord ) swap( bbb[X], bbb[Y] );
        //Piecewise<D2<SBasis> > dbg_rgnB = neighborhood( bbb, tol );
        D2<Piecewise<SBasis> > dbg_topB, dbg_botB;
        computeLinfinityNeighborhood( bbb, tol, dbg_topB, dbg_botB );
        cairo_set_line_width (cr, 1.);
        cairo_set_source_rgba(cr, .2, 8., .2, .4 );
//      cairo_pw_d2_sb(cr, dbg_rgnB );
        cairo_d2_pw_sb(cr, dbg_topB );
        cairo_d2_pw_sb(cr, dbg_botB );
        cairo_stroke(cr);
    }
 
    std::vector<Interval> bx_in_ax_range = level_set(bb[X], ax_range );
 
    // find times when bb is in the neighborhood of aa.
    std::vector<Interval> tbs;
    for (unsigned i=0; i<bx_in_ax_range.size(); i++){
        D2<Piecewise<SBasis> > bb_in;
        bb_in[X] = Piecewise<SBasis> ( portion( bb[X], bx_in_ax_range[i] ) );
        bb_in[Y] = Piecewise<SBasis> ( portion( bb[Y], bx_in_ax_range[i]) );
        bb_in[X].setDomain( bx_in_ax_range[i] );
        bb_in[Y].setDomain( bx_in_ax_range[i] );
 
        Piecewise<SBasis> h;
        Interval level;
        h = bb_in[Y] - compose( top_ay, bb_in[X] );
        level = Interval( -infinity(), 0 );
        std::vector<Interval> rts_lo = level_set( h, level);
        h = bb_in[Y] - compose( bot_ay, bb_in[X] );
        level = Interval( 0, infinity());
        std::vector<Interval> rts_hi = level_set( h, level);
 
        std::vector<Interval> rts = intersect( rts_lo, rts_hi );
        tbs.insert(tbs.end(), rts.begin(),  rts.end()  );
    }
 
    std::vector<std::pair<Interval, Interval> > result(tbs.size(),std::pair<Interval,Interval>());
 
    /* for each solution I, find times when aa is in the neighborhood of bb(I).
     * (Note: the preimage of bb[X](I) by aa[X], enlarged by tol, is a good approximation of this:
     * it would give points in the 2*tol neighborhood of bb (if the slope of aa is never more than 1).
     *  + faster computation.
     *  - implies little jumps depending on the subdivision of the input curve into monotonic pieces
     *  and on the choice of preferred axis. If noticeable, these jumps would feel random to the user :-(
     */
    for (unsigned j=0; j<tbs.size(); j++){
        result[j].second = tbs[j];
        std::vector<Interval> tas;
        Piecewise<SBasis> fat_y_of_x = y_of_x;
        prolongateByConstants( fat_y_of_x, 100*(1+tol) );
 
        D2<Piecewise<SBasis> > top_b, bot_b;
        D2<SBasis> bbj = portion( bb, tbs[j] );
        computeLinfinityNeighborhood( bbj, tol, top_b, bot_b );
 
        Piecewise<SBasis> h;
        Interval level;
        h = top_b[Y] - compose( fat_y_of_x, top_b[X] );
        level = Interval( +infinity(), 0 );
        std::vector<Interval> rts_top = level_set( h, level);
        for (unsigned idx=0; idx < rts_top.size(); idx++){
            rts_top[idx] = Interval( top_b[X].valueAt( rts_top[idx].min() ),
                                     top_b[X].valueAt( rts_top[idx].max() ) );
        }
        assert( rts_top.size() == 1 );
 
        h = bot_b[Y] - compose( fat_y_of_x, bot_b[X] );
        level = Interval( 0, -infinity());
        std::vector<Interval> rts_bot = level_set( h, level);
        for (unsigned idx=0; idx < rts_bot.size(); idx++){
            rts_bot[idx] = Interval( bot_b[X].valueAt( rts_bot[idx].min() ),
                                     bot_b[X].valueAt( rts_bot[idx].max() ) );
        }
        assert( rts_bot.size() == 1 );
 
#if VERBOSE
        printf("range(aa[X]) = [%f, %f];\n", y_of_x.domain().min(), y_of_x.domain().max());
        printf("range(bbj[X]) = [%f, %f]; tol= %f\n", bbj[X].at0(), bbj[X].at1(), tol);
 
        printf("rts_top = ");
        for (unsigned dbgi=0; dbgi<rts_top.size(); dbgi++){
            printf("[%f,%f]U", rts_top[dbgi].min(), rts_top[dbgi].max() );
        }
        printf("\n");
        printf("rts_bot = ");
        for (unsigned dbgi=0; dbgi<rts_bot.size(); dbgi++){
            printf("[%f,%f]U", rts_bot[dbgi].min(), rts_bot[dbgi].max() );
        }
        printf("\n");
#endif
        rts_top = intersect( rts_top, rts_bot );
#if VERBOSE
        printf("intersection = ");
        for (unsigned dbgi=0; dbgi<rts_top.size(); dbgi++){
            printf("[%f,%f]U", rts_top[dbgi].min(), rts_top[dbgi].max() );
        }
        printf("\n\n");
 
        if (rts_top.size() != 1){
            printf("!!!!!!!!!!!!!!!!!!!!!!\n!!!!!!!!!!!!!!!!!!!!!!\n");
            rts_top[0].unionWith( rts_top[1] );
            assert( false );
        }
#endif
        assert (rts_top.size() == 1);
        Interval x_dom = rts_top[0];
 
        if ( x_dom.max() <= x_range_strict.min() ){
            tas.push_back( Interval ( ( aa[X].at0() < aa[X].at1() ) ? 0 : 1 ) );
        }else if ( x_dom.min() >= x_range_strict.max() ){
            tas.push_back( Interval ( ( aa[X].at0() < aa[X].at1() ) ? 1 : 0 ) );
        }else{
            tas = level_set(aa[X], x_dom );
        }
 
#if VERBOSE
        if ( tas.size() != 1 ){
            printf("Error: preimage of [%f, %f] by x:[0,1]->[%f, %f] is ",
                    x_dom.min(), x_dom.max(), x_range_strict.min(), x_range_strict.max());
            if ( tas.size() == 0 ){
                printf( "empty.\n");
            }else{
                printf("\n   [%f,%f]", tas[0].min(), tas[0].max() );
                for (unsigned toto=1; toto<tas.size(); toto++){
                    printf(" U [%f,%f]", tas[toto].min(), tas[toto].max() );
                }
            }
        }
#endif
        assert( tas.size()==1 );
        result[j].first = tas.front();
    }
 
    if (swapresult) {
        for ( unsigned i=0; i<result.size(); i++){
            Interval temp = result[i].first;
            result[i].first = result[i].second;
            result[i].second = temp;
        }
    }
    return result;
}
 
#endif
 
class Intersector : public Toy
{
  private:
    void draw( cairo_t *cr, std::ostringstream *notify,
               int width, int height, bool save, std::ostringstream *timer_stream) override 
    {
        double tol = exp_rescale(slider.value());
        D2<SBasis> A = handles_to_sbasis(psh.pts.begin(), A_bez_ord-1);
        D2<SBasis> B = handles_to_sbasis(psh.pts.begin()+A_bez_ord, B_bez_ord-1);
        cairo_set_line_width (cr, .8);
        cairo_set_source_rgba(cr,0.,0.,0.,.6);
        cairo_d2_sb(cr, A);
        cairo_d2_sb(cr, B);
        cairo_stroke(cr);
 
        Rect tolbytol( anchor.pos, anchor.pos );
        tolbytol.expandBy( tol );
        cairo_rectangle(cr, tolbytol);
        cairo_stroke(cr);
/*
        Piecewise<D2<SBasis> > smthA = linearizeCusps(A+Point(0,10), tol);
        cairo_set_line_width (cr, 1.);
        cairo_set_source_rgba(cr, 1., 0., 1., 1. );
        cairo_pw_d2_sb(cr, smthA);
        cairo_stroke(cr);
*/
 
        std::vector<Interval> Acuts = monotonicSplit(A);
        std::vector<Interval> Bcuts = monotonicSplit(B);
 
#if 0
        for (unsigned i=0; i<Acuts.size(); i++){
            D2<SBasis> Ai = portion( A, Acuts[i]);
            cairo_set_line_width (cr, .2);
            cairo_set_source_rgba(cr, 0., 0., 0., 1. );
            draw_cross(cr, Ai.at0());
            cairo_stroke(cr);
            for (unsigned j=0; j<Bcuts.size(); j++){
                std::vector<std::pair<Interval, Interval> > my_intersections;
                D2<SBasis> Bj = portion( B, Bcuts[j]);
                cairo_set_line_width (cr, .2);
                cairo_set_source_rgba(cr, 0., 0., 0., 1. );
                draw_cross(cr, Bj.at0());
                cairo_stroke(cr);
            }
        }
#endif
 
        std::vector<SmashIntersection> my_intersections;
        my_intersections = smash_intersect( A, B, tol );
 
        for (auto & my_intersection : my_intersections){
            cairo_set_line_width (cr, 2.5);
            cairo_set_source_rgba(cr, 1., 0., 0., .8 );
            cairo_d2_sb(cr, portion( A, my_intersection.times[X]));
            cairo_stroke(cr);
            cairo_set_line_width (cr, 2.5);
            cairo_set_source_rgba(cr, 0., 0., 1., .8 );
            cairo_d2_sb(cr, portion( B, my_intersection.times[Y]));
            cairo_stroke(cr);
        }
#if 0
 
        unsigned apiece( slidera.value()/100. * Acuts.size() );
        unsigned bpiece( sliderb.value()/100. * Bcuts.size() );
 
 
        for (unsigned i=0; i<Acuts.size(); i++){
            D2<SBasis> Ai = portion( A, Acuts[i]);
            for (unsigned j=0; j<Bcuts.size(); j++){
                if ( toggle.on &&  (i != apiece || j != bpiece) ) continue;
 
                std::vector<SmashIntersection> my_intersections;
                D2<SBasis> Bj = portion( B, Bcuts[j]);
                bool draw_more = toggle.on &&  i == apiece && j == bpiece;
//              my_intersections = smash_intersect( Ai, Bj, tol, cr, draw_more );
                my_intersections = monotonic_smash_intersect( Ai, Bj, tol );
 
                for (unsigned k=0; k<my_intersections.size(); k++){
                    cairo_set_line_width (cr, 2.5);
                    cairo_set_source_rgba(cr, 1., 0., 0., .8 );
                    cairo_d2_sb(cr, portion( Ai, my_intersections[k].times[X]));
                    cairo_stroke(cr);
                    cairo_set_line_width (cr, 2.5);
                    cairo_set_source_rgba(cr, 0., 0., 1., .8 );
                    cairo_d2_sb(cr, portion( Bj, my_intersections[k].times[Y]));
                    cairo_stroke(cr);
                }
            }
        }
#endif
        Toy::draw(cr, notify, width, height, save,timer_stream);
    }
    
  public:
    Intersector(unsigned int _A_bez_ord, unsigned int _B_bez_ord)
        : A_bez_ord(_A_bez_ord), B_bez_ord(_B_bez_ord)
    {
        unsigned int total_handles = A_bez_ord + B_bez_ord;
        for ( unsigned int i = 0; i < total_handles; ++i )
            psh.push_back(Geom::Point(uniform()*400, uniform()*400));
        handles.push_back(&psh);
        slider = Slider(-4, 2, 0, 1.2, "tolerance");
        slider.geometry(Point(30, 20), 250);
        slider.formatter(&exp_formatter);
        handles.push_back(&slider);
        slidera = Slider(0, 100, 1, 0., "piece on A");
        slidera.geometry(Point(300, 50), 250);
        handles.push_back(&slidera);
        sliderb = Slider(0, 100, 1, 0., "piece on B");
        sliderb.geometry(Point(300, 80), 250);
        handles.push_back(&sliderb);
        toggle = Toggle( Rect(Point(300,10), Point(440,30)), "Piece by piece", false );
        handles.push_back(&toggle);
        anchor = PointHandle ( Point(100, 100 ) );
        handles.push_back(&anchor);
    }
    
  private:
    unsigned int A_bez_ord;
    unsigned int B_bez_ord;
    PointSetHandle psh;
    PointHandle anchor;
    Slider slider,slidera,sliderb;
    Toggle toggle;
};
 
 
int main(int argc, char **argv) 
{   
    unsigned int A_bez_ord=4;
    unsigned int B_bez_ord=4;
    if(argc > 2)
        sscanf(argv[2], "%d", &B_bez_ord);
    if(argc > 1)
        sscanf(argv[1], "%d", &A_bez_ord);
 
    init( argc, argv, new Intersector(A_bez_ord, B_bez_ord));
    return 0;
}
 
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :