Example #1
0
void ArrowMarker::setBoundingRect(double xs, double ys, double xe, double ye) {
  if (d_rect.left() == xs && d_rect.top() == ys && d_rect.right() == xe &&
      d_rect.bottom() == ye)
    return;

  d_rect.setLeft(xs);
  d_rect.setTop(ys);
  d_rect.setRight(xe);
  d_rect.setBottom(ye);

  if (!plot())
    return;

  plot()->updateLayout();
  d_start =
      QPoint(plot()->transform(xAxis(), xs), plot()->transform(yAxis(), ys));
  d_end =
      QPoint(plot()->transform(xAxis(), xe), plot()->transform(yAxis(), ye));
}
Example #2
0
function run()
{
	set(PLOTNOW);
	NumYears = 1;
	MaxBars = 210;
	PlotScale = 8;
	PlotWidth = 800;
	PlotHeight1 = 350;
	PlotHeight2 = 80;
	vars Price = series(price());
	
// plot Bollinger bands
	BBands(Price,30,2,2,MAType_SMA);
	plot("Bollinger1",rRealUpperBand,BAND1,0x00CC00);
	plot("Bollinger2",rRealLowerBand,BAND2,0xCC00FF00);
	plot("SAR",SAR(0.02,0.02,0.2),DOT,RED);
	ZigZag(Price,20*PIP,5,BLUE);
	
// plot some other indicators	
	plot("ATR (PIP)",ATR(20)/PIP,NEW,RED);
	plot("Doji",CDLDoji(),NEW+BARS,BLUE);
	plot("FractalDim",FractalDimension(Price,30),NEW,RED);
	plot("ShannonGain",ShannonGain(Price,40),NEW,RED);
}
Example #3
0
void QtDensity::runRandomDataCmd(void) {
    std::string cmd = "y <- " + m_cmd.toStdString();
    m_R.parseEvalQ(cmd);
    plot();                     // after each random draw, update plot with estimate
}
Example #4
0
void QtDensity::getBandwidth(int bw) {
    if (bw != m_bw) {
        m_bw = bw;
        plot();
    }
}
Example #5
0
void Mandelbrot::generate(int maxIterations, unsigned int ty, unsigned int height)
{
    double real = (m_maxReal - m_minReal) / m_width;
    double imag = (m_maxImag - m_minImag) / m_height;

    for(unsigned int x = 0; x < m_width; x++)
    {
        for(unsigned int y = ty; y < height; y++)
        {
            double cx = m_minReal + x * real + m_center.x * real; 
            double cy = m_maxImag - y * imag - m_center.y * imag;

            double zx = cx;
            double zy = cy;

            int iteration = 0;

            while(zx*zx + zy*zy < 4 && iteration < maxIterations)
            {
                double tempX = zx*zx - zy*zy + cx;
                double tempY = 2 * zx * zy + cy;

                if(zx == tempX && zy == tempY) {
                    iteration = maxIterations;
                    break;
                }

                zx = tempX;
                zy = tempY;

                iteration++;
            }

            if(iteration == maxIterations)
                plot(x, y, sf::Color::Black);
            else 
            {
                sf::Color color;

                if (iteration == maxIterations) {
                  color = sf::Color(0, 0, 0);
                } else if (iteration < 64) {
                  color = sf::Color(iteration * 2, 0, 0);
                } else if (iteration < 128) {
                  color = sf::Color((((iteration - 64) * 128) / 126) + 128, 0, 0);
                } else if (iteration < 256) {
                  color = sf::Color((((iteration - 128) * 62) / 127) + 193, 0, 0); 
                } else if (iteration < 512) {
                  color = sf::Color(255, (((iteration - 256) * 62) / 255) + 1, 0);
                } else if (iteration < 1024) {
                  color = sf::Color(255, (((iteration - 512) * 63) / 511) + 64, 0);
                } else if (iteration < 2048) {
                  color = sf::Color(255, (((iteration - 1024) * 63) / 1023) + 128, 0);
                } else if (iteration < 4096) {
                  color = sf::Color(255, (((iteration - 2048) * 63) / 2047) + 192, 0);
                } else {
                  color = sf::Color(iteration, iteration, 0);
                }

                plot(x, y, color);
            }
        }
    }

    m_texture.update(m_pixels);
}
Example #6
0
void LegendItem::paint(QPainter *painter) {
  if (!isVisible()) {
    return;
  }

  RelationList legendItems;
  if (_auto) {
    legendItems = plot()->renderItem(PlotRenderItem::Cartesian)->relationList();
  } else {
    legendItems = _relations;
  }

  int count = legendItems.count();
  if (count <= 0) { // no legend or box if there are no legend items
    return;
  }


  QFont font(_font);
  font.setPointSizeF(view()->scaledFontSize(_fontScale, *painter->device()));

  painter->setFont(font);

  // generate string list of relation names
  QStringList names;
  bool allAuto = true;
  bool sameX = true;
  bool sameYUnits = true;

  LabelInfo label_info = legendItems.at(0)->xLabelInfo();
  QString yUnits =  legendItems.at(0)->yLabelInfo().units;

  for (int i = 0; i<count; i++) {
    RelationPtr relation = legendItems.at(i);
    if (relation->descriptiveNameIsManual()) {
      allAuto = false;
    }
    if (relation->xLabelInfo() != label_info) {
      sameX = false;
    }
    // sameYUnits is false if any non empty units are defined differently.
    if (yUnits.isEmpty()) {
      yUnits = relation->yLabelInfo().units;
    } else if (relation->yLabelInfo().units != yUnits) {
      if (!relation->yLabelInfo().units.isEmpty()) {
        sameYUnits = false;
      }
    }
  }

  if (!allAuto) {
    for (int i = 0; i<count; i++) {
      names.append(legendItems.at(i)->descriptiveName());
    }
  } else {
    for (int i = 0; i<count; i++) {
      RelationPtr relation = legendItems.at(i);
      QString label = relation->titleInfo().singleRenderItemLabel();
      if (label.isEmpty()) {
        label_info = relation->yLabelInfo();
        QString y_label = label_info.name;
        if (!sameYUnits) {
          if (!label_info.units.isEmpty()) {
            y_label = tr("%1 \\[%2\\]", "axis labels.  %1 is quantity, %2 is units.  eg Time [s].  '[' must be escaped.").arg(y_label).arg(label_info.units);
          }
        }
        if (!y_label.isEmpty()) {
          LabelInfo xlabel_info = relation->xLabelInfo();
          if (!sameX) {
            label = tr("%1 vs %2", "describes a plot. %1 is X axis.  %2 is Y axis").arg(y_label).arg(xlabel_info.name);
          } else if (xlabel_info.quantity.isEmpty()) {
            label = y_label;
          } else if (xlabel_info.quantity != xlabel_info.name) {
            label = tr("%1 vs %2", "describes a plot. %1 is X axis.  %2 is Y axis").arg(y_label).arg(xlabel_info.name);
          } else {
            label = y_label;
          }
        } else {
          label = relation->descriptiveName();
        }
      }
      int i_dup = names.indexOf(label);
      if (i_dup<0) {
        names.append(label);
      } else {
        RelationPtr dup_relation = legendItems.at(i_dup);
        if (!dup_relation->yLabelInfo().file.isEmpty()) {
          names.replace(i_dup, label + " (" + dup_relation->yLabelInfo().escapedFile() + ')');
        }
        if (!relation->yLabelInfo().file.isEmpty()) {
          names.append(label + " (" + relation->yLabelInfo().escapedFile() + ')');
        }
      }
    }
  }


  QSize legendSize(0, 0);
  QSize titleSize(0,0);
  Label::Parsed *parsed = Label::parse(_title);
  int pad = painter->fontMetrics().ascent()/4;
  Label::RenderContext rc(painter->font(), painter);
  Label::renderLabel(rc, parsed->chunk, false, false);

  if (!_title.isEmpty()) {
    titleSize.setWidth(rc.x+3*pad);
    titleSize.setHeight(painter->fontMetrics().height()+pad);
  }

  QList<QSize> sizes;
  int max_w = 0;
  int max_h = 0;
  for (int i = 0; i<count; i++) {
    RelationPtr relation = legendItems.at(i);
    QSize size;
    painter->save();
    size = paintRelation(names.at(i), relation, painter, false);
    painter->restore();
    sizes.append(size);
    max_w = qMax(max_w, size.width());
    max_h = qMax(max_h, size.height());
  }

  // determine number of rows and number of columns
  int n_rows = 0;
  int n_cols = 0;
  if (_verticalDisplay) {
    int h=titleSize.height();
    for (int i = 0; i<count; i++) {
      h+=sizes.at(i).height();
    }
    int max_legend_height = _plotItem->plotRect().height()*0.6+1;
    n_cols = qMin(count, h / max_legend_height + 1);
    n_rows = count / n_cols;
    while (n_rows*n_cols<count) {
      n_rows++;
    }
  } else {
    int w = 0;
    for (int i = 0; i<count; i++) {
      w+=sizes.at(i).width();
    }
    int max_legend_width = _plotItem->plotRect().width()*0.8+1;
    n_rows = qMin(count, w / max_legend_width+1);
    n_cols = count/n_rows;
    while (n_rows*n_cols<count) {
      n_cols++;
    }
  }

  // determine the dimensions of each column
  QList<QSize> col_sizes;
  for (int i=0; i<n_cols; i++) {
    col_sizes.append(QSize(0,0));
  }
  for (int i = 0; i<count; i++) {
    int col = i/n_rows;
    col_sizes[col].rheight()+= sizes.at(i).height();
    col_sizes[col].setWidth(qMax(sizes.at(i).width(), col_sizes.at(col).width()));
  }

  // determine the dimensions of the legend
  int w = 0;
  int h = 0;
  for (int col = 0; col < n_cols; col++) {
    w += col_sizes.at(col).width();
    h = qMax(h, col_sizes.at(col).height());
  }
  legendSize.setHeight(h + titleSize.height());
  legendSize.setWidth(qMax(titleSize.width(), w));
  setViewRect(rect().x(), rect().y(), legendSize.width()+pad, legendSize.height()+pad);

  // Now paint everything
  painter->drawRect(rect());

  int x=rect().x();
  int y=rect().y();

  if (!_title.isEmpty()) {
    rc.y = rect().y() + titleSize.height()-pad;
    rc.x = qMax(rect().x()+pad, rect().x() + legendSize.width()/2 - titleSize.width()/2);
    Label::renderLabel(rc, parsed->chunk, false, true);
    y+= titleSize.height();
  }

  legendSize.setWidth(0);
  legendSize.setHeight(0);
  for (int i = 0; i<count; i++) {
    RelationPtr relation = legendItems.at(i);
    painter->save();
    painter->translate(x,y);
    paintRelation(names.at(i), relation, painter, true);
    painter->restore();

    int col = i/n_rows;
    int row = i%n_rows;
    if (row == n_rows-1) { // end of a column
      x += col_sizes.at(col).width();
      y = rect().y() + titleSize.height();
    } else {
      y += sizes.at(i).height();
    }
  }
  delete parsed;
}
Example #7
0
int main ( int argc, char **argv )
{
    srand(time(NULL));
    if ( argc<=1 )
    {
        //      printf ( "neuro num\r\n" );
        //     exit ( 0 );
    }

    if (argc>2)
    {
        //desired_error=atof(argv[2]);
        numn=atoi(argv[1]);
        l1n=atoi(argv[2]);
        if (argc>3)
            l2n=atoi(argv[3]);
        if (argc>4)
            l3n=atoi(argv[4]);
        if (argc>5)
            l4n=atoi(argv[5]);
        if (argc>6)
            l5n=atoi(argv[6]);
        if (argc>7)
            l6n=atoi(argv[7]);
    }

    signal ( 2, sig_term );



    srand ( time ( NULL ) );

    printf("loading training data...");

    train_data = fann_read_train_from_file ( "train.dat" );
    test_data = fann_read_train_from_file ( "test.dat" );

    weight_data=fann_merge_train_data(train_data,test_data);

    cln_weight_data=fann_duplicate_train_data(weight_data);
    cln_test_data=fann_duplicate_train_data(test_data);
    cln_train_data=fann_duplicate_train_data(train_data);

    //num_neurons_hidden = atoi ( argv[1] );



    srand(time(NULL));

    y=atoi(argv[2]);

    lay=atoi(argv[1]);
    ln=lay+2;
    if (lay==1)
        y2=train_data->num_output;
    best_perc=1;

    printf("\r\ndoing %ux%u [layers=%u,out=%u]",lay,y,ln, train_data->num_output);
    while (true)

    {
        neur1=1+(rand()%y);
        neur2=1+(rand()%y);
        conn_rate=0.5f+((rand()%50)*0.01f);
        printf("\r\n%2dx%-4d: ",neur1,neur2);
        //  printf("create network: layers=%d l1n=%d l2n=%d l3n=%d l4n=%d\ l5n=%d l6n=%dr\n",numn,l1n,l2n,l3n,l4n,l5n,l6n);
        ann = fann_create_standard (//conn_rate,
                  ln,
                  train_data->num_input,
                  neur1,
                  neur2,
                  train_data->num_output );
        //fann_init_weights ( ann, train_data );
        printf(" [%p] ",ann);

        if ( ( int ) ann==NULL )
        {
            printf ( "error" );
            exit ( 0 );
        }



        fann_set_activation_function_hidden(ann,FANN_SIGMOID);
        fann_set_activation_function_output(ann,FANN_SIGMOID);

        rebuild_functions(neur1);
        fann_set_training_algorithm ( ann, FANN_TRAIN_RPROP );
        fann_set_sarprop_temperature(ann,15000.0f);
        //fann_randomize_weights ( ann, -((rand()%10)*0.1f), ((rand()%10)*0.1f) );
        fann_init_weights(ann,train_data);
        got_inc=0;
        prev_epoch_mse=1;
        //
        epochs=0;

        unsigned last_best_perc_epoch=0;
        unsigned last_sync_epoch=0;
        unsigned last_ftest_secs=0;

        last_sync_epoch=0;
        last_best_perc_epoch=0;
        if (good_ann)
            fann_destroy(good_ann);

        good_ann=fann_copy(ann);
        unlink(histfile);
        for (u=0;u<1000;u++)
        {
            fflush(NULL);
            train_mse=fann_train_epoch(ann, train_data);

            if (jitter_train)
                apply_jjit(train_data,cln_train_data);


            if (time(NULL)-last_ftest_secs>=1)
            {
                //printf("\r\n%5u %9.6f %5.2f ",epochs,train_mse,test_perc);
                //printf(" %4.2f",test_perc);
                printf(".");


                last_ftest_secs=time(NULL);
            }
            ftest_data();
            plot(epochs,train_mse,test_mse);

            /*         if (epochs>10&&((int)test_perc==43||(int)test_perc==57))
                    {
                        printf(" [excluded %.2f] ",test_perc);
                        break;
                    }            else            {

                    } */
            //printf("excluded %f ",test_perc);

            double prev_test_perc;
            //   if (prev_epoch_mse==best_perc)
            //  printf("o");
            if ((int)test_perc>(int)train_perc&&epochs-last_stat_epoch>10)
            {
                fann_destroy(good_ann);
                good_ann=fann_copy(ann);

                if (test_perc!=prev_test_perc)
                    printf("%.2f [%f]",test_perc,train_mse);

                //printf(" sync[%4.2f]",test_perc);
                last_stat_epoch=epochs;
            }
            else 	if (epochs-last_sync_epoch>111500)
            {
                last_sync_epoch=epochs;
            }
            if (epochs>210&&test_perc>best_perc)
            {
                //	u--;
                //  fann_destroy(good_ann);
                //   good_ann=fann_copy(ann);
                printf(" [saved best %.0f] ",test_perc);
                last_stat_epoch=epochs;
                //		printf("%f",test_perc);
                //	fann_destroy(ann);
                //	ann=fann_copy(good_ann);
                fann_save(ann,"mutate-best.net");
                best_perc=test_perc;
                printf(" %6.2f [%f]",test_perc,train_mse);
                last_best_perc_epoch=epochs;

            }
            else     if (epochs>11100&&((int)test_perc<=63||(int)test_perc==(int)prev_test_perc))
            {
                //best_perc=test_perc;
                //		printf("x");
                //  printf(".");
                //printf("\r%6.8f",train_mse);
                //			printf("done\r\n");
                break;


            }
            static unsigned last_restore_epoch=0;
            if (epochs>100&&test_mse-train_mse>=0.25f&&epochs-last_restore_epoch>=120)
            {
                /* 	fann_set_learning_rate ( ann,0.31f+(rand()%90)*0.01f);
                	fann_set_learning_momentum(ann,(rand()%90)*0.01f);
                	printf(" [restored @ %u lr %.2f mm %.2f]",epochs,fann_get_learning_rate(ann),
                	fann_get_learning_momentum(ann));
                	fann_destroy(ann);
                	ann=fann_copy(good_ann);
                	last_stat_epoch=epochs;
                	last_restore_epoch=epochs; */





                double rdec,rinc;
                rdec=0.0101f+((rand()%100)*0.00001f);
                if (!rdec)
                    rdec=0.01f;
                rinc=1.0001f+((rand()%90)*0.00001f);
                if (!rinc)
                    rinc=1.1f;
                static double prev_test_epoch_mse;

                //		rinc+=diff_mse*0.000001f;
                //			fann_set_rprop_increase_factor(ann,rinc );
                //	fann_set_rprop_decrease_factor(ann, rdec);
            }
            else if (test_mse-train_mse<=0.1f)
            {
                fann_destroy(good_ann);
                good_ann=fann_copy(ann);
                //	printf("s");
            }
            else
            {
                fann_set_sarprop_temperature(ann,fann_get_sarprop_temperature(ann)-0.0001f);
            }
            static unsigned last_train_change_epoch=0;
            if (test_mse>=train_mse&&epochs-last_train_change_epoch>=100)
            {
                last_train_change_epoch=epochs;
                //fann_set_training_algorithm(ann,FANN_TRAIN_SARPROP);
                jitter_train=0;
            }
            else
            {
                //fann_set_training_algorithm(ann,FANN_TRAIN_RPROP);
                jitter_train=0;
            }

            got_inc=test_perc-prev_epoch_mse;
            prev_epoch_mse=test_perc;
            prev_test_perc=test_perc;
            epochs++;
            if (epochs-last_best_perc_epoch>511500)
            {
                printf(" failed");
                break;
            }
            if (epochs>2200&&(int)train_perc<40)
            {
                printf("skip 1\r\n");
                break;
            }

            if ((int)test_perc>=80)
            {
                printf("\r\ngot it %f\r\n",test_perc);
                fann_save(ann,"good.net");
                exit(0);
            }
            // printf("\n%6u ",epochs);
        }
        printf(" %6.2f inc: %.2f",test_perc,got_inc);
//            printf("%6.2f %6.2f",train_perc,test_perc);

        fann_destroy ( ann );

    }

    fann_destroy_train ( train_data );
    fann_destroy_train ( test_data );
    fann_destroy ( ann );

    return 0;
}
Example #8
0
void GeomGlut::plot( GLfloat x, GLfloat y )
{
    plot(x, y, DEFAULT_SIZE_POINT);
}
void compare_Mtt_distribution_fitting(){

  gStyle->SetOptStat(0);
  gStyle->SetOptTitle(0);
  gStyle->SetPadRightMargin(0.03);
  gStyle->SetPadLeftMargin(0.16);


  TFile *file;
  TH1F* h_vbf_tight[3];
  TH1F* h_vbf_loose[3];
  TH1F* h_1jet[3];
  TH1F* h_vbf_tight_signal[3];
  TH1F* h_vbf_loose_signal[3];
  TH1F* h_1jet_signal[3];


  /*
   * VBF tight category for 8TeV
   */

  for(int ichannel=0; ichannel < 3; ichannel++){
     
    TString fname = file_8TeV[ichannel];
    file = new TFile(fname);
    
    TString getname = ch_name[ichannel];
    getname += "_vbf_tight/";
    TString name = getname + process_name[ichannel];
    h_vbf_tight[ichannel] = (TH1F*) file->Get(name);

    // signal 

    TString sname = getname;
    sname += "ggH125";
    h_vbf_tight_signal[ichannel] = (TH1F*) file->Get(sname);

    sname = getname;
    sname += "qqH125";
    h_vbf_tight_signal[ichannel]->Add((TH1F*) file->Get(sname));
    
    sname = getname;
    sname += "VH125";
    h_vbf_tight_signal[ichannel]->Add((TH1F*) file->Get(sname));


    //////////////////////////

    getname = ch_name[ichannel];
    getname += "_vbf_loose/";
    TString name = getname + process_name[ichannel];
    h_vbf_loose[ichannel] = (TH1F*) file->Get(name);

    // signal

    sname = getname;
    sname += "ggH125";
    h_vbf_loose_signal[ichannel] = (TH1F*) file->Get(sname);

    sname = getname;
    sname += "qqH125";
    h_vbf_loose_signal[ichannel]->Add((TH1F*) file->Get(sname));
    
    sname = getname;
    sname += "VH125";
    h_vbf_loose_signal[ichannel]->Add((TH1F*) file->Get(sname));
				

    /////////////////////////


    getname = ch_name[ichannel];
    if(ichannel==2) getname += "_1jet_high/";
    else getname += "_1jet_high_mediumhiggs/";

    TString name = getname + process_name[ichannel];
    h_1jet[ichannel] = (TH1F*) file->Get(name);

    
    // signal

    sname = getname;
    sname += "ggH125";
    h_1jet_signal[ichannel] = (TH1F*) file->Get(sname);

    sname = getname;
    sname += "qqH125";
    h_1jet_signal[ichannel]->Add((TH1F*) file->Get(sname));
    
    sname = getname;
    sname += "VH125";
    h_1jet_signal[ichannel]->Add((TH1F*) file->Get(sname));
				
  }



  plot(h_vbf_tight_signal, h_vbf_tight, "VBF_tight","8TeV");
  plot(h_vbf_loose_signal, h_vbf_loose, "VBF_loose","8TeV");
  plot(h_1jet_signal, h_1jet, "1jet_high","8TeV");


  /////////////////// 7 TeV ////////////////////////////

  TH1F* hh_vbf[3];
  TH1F* hh_1jet[3];
  TH1F* hh_vbf_signal[3];
  TH1F* hh_1jet_signal[3];


  /*
   * VBF tight category for 8TeV
   */

  for(int ichannel=0; ichannel < 3; ichannel++){
     
    TString fname = file_7TeV[ichannel];
    file = new TFile(fname);
    
    TString getname = ch_name[ichannel];
    if(ichannel==2) getname += "_vbf_loose/";
    else getname += "_vbf/";

    TString name = getname + process_name[ichannel];
    hh_vbf[ichannel] = (TH1F*) file->Get(name);

    // signal 

    TString sname = getname;
    sname += "ggH125";
    hh_vbf_signal[ichannel] = (TH1F*) file->Get(sname);

    sname = getname;
    sname += "qqH125";
    hh_vbf_signal[ichannel]->Add((TH1F*) file->Get(sname));
    
    sname = getname;
    sname += "VH125";
    hh_vbf_signal[ichannel]->Add((TH1F*) file->Get(sname));


    //////////////////////////


    getname = ch_name[ichannel];
    if(ichannel==2) getname += "_1jet_high/";
    else getname += "_1jet_high_mediumhiggs/";

    TString name = getname + process_name[ichannel];
    hh_1jet[ichannel] = (TH1F*) file->Get(name);

    
    // signal

    sname = getname;
    sname += "ggH125";
    hh_1jet_signal[ichannel] = (TH1F*) file->Get(sname);

    sname = getname;
    sname += "qqH125";
    hh_1jet_signal[ichannel]->Add((TH1F*) file->Get(sname));
    
    sname = getname;
    sname += "VH125";
    hh_1jet_signal[ichannel]->Add((TH1F*) file->Get(sname));
				
  }



  plot(hh_vbf_signal, hh_vbf, "VBF","7TeV");
  plot(hh_1jet_signal, hh_1jet, "1jet","7TeV");


}
Example #10
0
static int drawvect(int zoomit,	/* -1 = refresh, 0 = new image, 1 = zoom, 2 = warp */
		    View * zoom_view, double E[], double N[], int trans_order)
{				/* order of transformation if warping vectors */
    int stat = 0;
    int i;
    char name[GNAME_MAX], mapset[GMAPSET_MAX];
    struct Cell_head cellhd;
    struct line_pnts *Points;
    char msg[100], win_name[100];
    int t, b, l, r;
    int blank = 0;
    View *active_view;
    int left, top, nrows, ncols;
    static int vectclr[VFILES];


    /* if refresh screen or overlay & no displayed vector maps return */
    if ((zoomit == DO_REFRESH || zoomit == DO_WARP) && !numfiles) {
	if (zoomit == DO_REFRESH)
	    display_points(1);
	return 0;
    }

    /* numfiles stays at 0 until the end of the first vector map init */

    if (numfiles >= VFILES) {
	G_warning
	    ("Can't display another map; reached maximum number of files");
	return 0;
    }

    select_target_env();

    if (zoomit == DO_REFRESH || zoomit == DO_NEW) {	/* New Map File or Refresh Screen */

	if (zoomit == DO_NEW) {	/* zoomit==0, Draw New Map File */
	    if (!choose_vectfile(name, mapset))
		return 0;

	    strcpy(vect_file[numfiles], name);
	    strcpy(vect_mapset[numfiles], mapset);

	    get_vector_color();	/* ask line_color to draw map */

	    if (!numfiles) {	/* first map: SET VECTOR WINDOW BY WIND */
		G_get_window(&cellhd);
		G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));
	    }
	    else		/* not the first map */
		G_copy(&cellhd, &VIEW_MAP2->cell.head,
		       sizeof(VIEW_MAP2->cell.head));

	    numfiles++;

	}
	else {			/* zoomit=-1 Refresh Screen */
	    G_copy(&cellhd, &VIEW_MAP2->cell.head,
		   sizeof(VIEW_MAP2->cell.head));

	    if (!cellmap_present)
		Erase_view(VIEW_MAP2_ZOOM);

	    VIEW_MAP2_ZOOM->cell.configured = 0;
	    blank = BLACK;
	}

	strcpy(win_name, "vect_map");
	if (!view2on) {
	    t = VIEW_MAP2->top;
	    b = VIEW_MAP2->bottom;
	    l = VIEW_MAP2->left;
	    r = VIEW_MAP2->right;
	    D_new_window(win_name, t, b, l, r);
	    if (!cellmap_present)
		blank = BLACK;
	    else
		blank = 0;	/* don't erase viewport */
	    view2on = 1;
	}

	active_view = VIEW_MAP2;
    }
    else {			/* zoomit>0   Zoom or Warp */

	G_copy(&cellhd, &zoom_view->cell.head, sizeof(zoom_view->cell.head));

	if (!(zoom_view == VIEW_MAP1)) {	/* target side */
	    VIEW_MAP2_ZOOM->cell.configured = 0;
	    strcpy(win_name, "zoom_map");
	    if (!view2zoomon) {
		t = VIEW_MAP2_ZOOM->top;
		b = VIEW_MAP2_ZOOM->bottom;
		l = VIEW_MAP2_ZOOM->left;
		r = VIEW_MAP2_ZOOM->right;
		D_new_window(win_name, t, b, l, r);
		view2zoomon = 1;

	    }
	    active_view = VIEW_MAP2_ZOOM;
	    blank = BLACK;
	}
	else {
	    strcpy(win_name, "warp_map");	/* defined in drawcell routine */
	    active_view = VIEW_MAP1;
	    blank = 0;		/* don't erase viewport */
	}
    }

    nrows = active_view->nrows;
    ncols = active_view->ncols;
    left = active_view->left;
    top = active_view->top;

    D_set_cur_wind(win_name);
    R_standard_color(YELLOW);
    Outline_box(top, top + nrows - 1, left, left + ncols - 1);
    Points = Vect_new_line_struct();

    if (zoomit != DO_WARP) {
	Curses_clear_window(INFO_WINDOW);
	Curses_write_window(INFO_WINDOW, 1, 13, "COORDINATES");
	Curses_write_window(INFO_WINDOW, 3, 2, "MAIN WINDOW");

	sprintf(msg, "N = %10.2f   E = %10.2f", VIEW_MAP2->cell.head.north,
		VIEW_MAP2->cell.head.east);
	Curses_write_window(INFO_WINDOW, 5, 4, msg);
	sprintf(msg, "S = %10.2f   W = %10.2f", VIEW_MAP2->cell.head.south,
		VIEW_MAP2->cell.head.west);
	Curses_write_window(INFO_WINDOW, 6, 4, msg);

	Curses_write_window(INFO_WINDOW, 9, 2, "ZOOM WINDOW");
	sprintf(msg, "N = %10.2f   E = %10.2f",
		VIEW_MAP2_ZOOM->cell.head.north,
		VIEW_MAP2_ZOOM->cell.head.east);
	Curses_write_window(INFO_WINDOW, 11, 4, msg);
	sprintf(msg, "S = %10.2f   W = %10.2f",
		VIEW_MAP2_ZOOM->cell.head.south,
		VIEW_MAP2_ZOOM->cell.head.west);
	Curses_write_window(INFO_WINDOW, 12, 4, msg);
    }

    if (zoomit) {		/* ie ! DO_NEW */

	dsp_setup(blank, &cellhd);

	for (i = 0; i < numfiles; i++) {
	    sprintf(msg, "Displaying %s", vect_file[i]);
	    Menu_msg(msg);
	    R_standard_color(vectclr[i]);
	    if (zoomit != DO_WARP)
		stat = plot(vect_file[i], vect_mapset[i], Points);
	    else
		stat = plot_warp(vect_file[i], vect_mapset[i],
				 Points, E, N, trans_order);
	}
    }
    else {			/* ie DO_NEW */

	if (numfiles == 1) {	/* let first file set window */
	    G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));

	    cellhd.rows = VIEW_MAP2->nrows;
	    cellhd.cols = VIEW_MAP2->ncols;
	    cellhd.ns_res = (cellhd.north - cellhd.south) / cellhd.rows;
	    cellhd.ew_res = (cellhd.east - cellhd.west) / cellhd.cols;
	    if (cellhd.ns_res > cellhd.ew_res)
		cellhd.ew_res = cellhd.ns_res;
	    else
		cellhd.ns_res = cellhd.ew_res;

	    VIEW_MAP2->cell.ns_res = cellhd.ns_res;
	    VIEW_MAP2->cell.ew_res = cellhd.ew_res;

	    G_copy(&VIEW_MAP2->cell.head, &cellhd, sizeof(cellhd));

	    G_adjust_window_to_box(&cellhd, &VIEW_MAP2->cell.head,
				   VIEW_MAP2->nrows, VIEW_MAP2->ncols);

	    if (!cellmap_present) {
		Configure_view(VIEW_MAP2, vect_file[numfiles - 1],
			       vect_mapset[numfiles - 1], cellhd.ns_res,
			       cellhd.ew_res);
	    }

	    Curses_write_window(INFO_WINDOW, 15, 2,
				"WHERE CURSOR-> Mid Button");
	}

	dsp_setup(blank, &cellhd);

	R_standard_color(YELLOW);
	Outline_box(top, top + nrows - 1, left, left + ncols - 1);

	sprintf(msg, "Displaying %s", vect_file[numfiles - 1]);
	Menu_msg(msg);

	R_standard_color(line_color);
	vectclr[numfiles - 1] = line_color;

	get_clr_name(vect_color[numfiles - 1], line_color);

	stat =
	    plot(vect_file[numfiles - 1], vect_mapset[numfiles - 1], Points);

    }

    display_points(1);

    R_standard_color(WHITE);
    Outline_box(top, top + nrows - 1, left, left + ncols - 1);

    Menu_msg("");

    Vect_destroy_line_struct(Points);

    /*    VIEW_MAP2->cell.configured = 1; XXX */

    select_current_env();
    if (from_screen < 0) {
	from_flag = 1;
	from_screen = 0;
	if (from_keyboard < 0) {
	    from_keyboard = 0;
	    from_screen = 1;
	}
    }

    if (numfiles) {
	Curses_clear_window(MENU_WINDOW);
	Curses_write_window(MENU_WINDOW, 1, 5, "COLOR  MAP FILE");
	for (i = 0; i < numfiles; i++) {
	    sprintf(msg, "%7s  %s", vect_color[i], vect_file[i]);
	    Curses_write_window(MENU_WINDOW, i + 3, 3, msg);
	}
    }

    return 0;
}
Example #11
0
File: main.c Project: stuydw/matrix
int main() {

  //Basic Matrix Math
  struct matrix *a;
  struct matrix *b;

  a=new_matrix(4,4);
  b=new_matrix(4,2);
 
  
  printf("Identity matrix:\n");
  ident(a);
  print_matrix(a);
  
  b->m[0][0]=1;
  b->m[0][1]=2;
  b->m[1][0]=3;
  b->m[1][1]=4;
  b->m[2][0]=5;
  b->m[2][1]=6;
  b->m[3][0]=7;
  b->m[3][1]=8;
  
  printf("Matrix #2:\n");
  print_matrix(b);
  
  printf("Scalar Multiplication by 2:\n");
  scalar_mult(2, b);
  print_matrix(b);
  
  printf("New Matrix #1:\n");
  a->m[2][1]=3;
  a->m[0][3]=2;
  print_matrix(a);
  
  printf("Matrix Multiplication:\n");
  matrix_mult(a, b);
  print_matrix(b);

  printf("Adding points/edges:\n");
  struct matrix *d;
  d = new_matrix(3, 3);
  add_point(d, 200,400,70);
  add_point(d, 200,0,7);
  print_matrix(d);
  printf("\n");
  add_edge(d, 300,500,100,300,100,134);
  add_edge(d, 100,500,100,100,100,134);
  add_edge(d, 400,00,100,400,400,134);
  print_matrix(d);
  printf("\n");


  screen s;
  color c;

  c.red = 200;
  c.green = 100;
  c.blue = 250;

  int i, j;



  for( i=0; i<XRES; i++) 
    for ( j=0; j<YRES; j++) {
      plot( s, c, i, j);
    }

  c.red=0;
  c.green=200;
  c.blue=200;

  draw_lines(d, s, c);
 
  display( s );    
  save_ppm(s,  "image" );
  save_extension(s, "image.jpg");
  
}  
void QwtPlotCanvas::drawCanvas( QPainter *painter, bool withBackground ) 
{
    bool hackStyledBackground = false;

    if ( withBackground && testAttribute( Qt::WA_StyledBackground ) 
        && testPaintAttribute( HackStyledBackground ) )
    {
        // Antialiasing rounded borders is done by
        // inserting pixels with colors between the 
        // border color and the color on the canvas,
        // When the border is painted before the plot items
        // these colors are interpolated for the canvas
        // and the plot items need to be clipped excluding
        // the anialiased pixels. In situations, where
        // the plot items fill the area at the rounded
        // borders this is noticeable.
        // The only way to avoid these annoying "artefacts"
        // is to paint the border on top of the plot items.

        if ( d_data->styleSheet.hasBorder &&
            !d_data->styleSheet.borderPath.isEmpty() )
        {
            // We have a border with at least one rounded corner
            hackStyledBackground = true;
        }
    }

    if ( withBackground )
    {
        painter->save();

        if ( testAttribute( Qt::WA_StyledBackground ) )
        {
            if ( hackStyledBackground )
            {
                // paint background without border

                painter->setPen( Qt::NoPen );
                painter->setBrush( d_data->styleSheet.background.brush ); 
                painter->setBrushOrigin( d_data->styleSheet.background.origin );
                painter->setClipPath( d_data->styleSheet.borderPath );
                painter->drawRect( contentsRect() );
            }
            else
            {
                qwtDrawStyledBackground( this, painter );
            }
        }
        else if ( autoFillBackground() )
        {
            painter->setPen( Qt::NoPen );
            painter->setBrush( palette().brush( backgroundRole() ) );

            if ( d_data->borderRadius > 0.0 && ( rect() == frameRect() ) )
            {
                if ( frameWidth() > 0 )
                {
                    painter->setClipPath( borderPath( rect() ) );
                    painter->drawRect( rect() );
                }
                else
                {
                    painter->setRenderHint( QPainter::Antialiasing, true );
                    painter->drawPath( borderPath( rect() ) );
                }
            }
            else
            {
                painter->drawRect( rect() );
            }
        }

        painter->restore();
    }

    painter->save();

    if ( !d_data->styleSheet.borderPath.isEmpty() )
    {
        painter->setClipPath( 
            d_data->styleSheet.borderPath, Qt::IntersectClip );
    }
    else
    {
        if ( d_data->borderRadius > 0.0 )
            painter->setClipPath( borderPath( frameRect() ), Qt::IntersectClip );
        else
            painter->setClipRect( contentsRect(), Qt::IntersectClip );
    }

    plot()->drawCanvas( painter );

    painter->restore();

    if ( withBackground && hackStyledBackground )
    {
        // Now paint the border on top
        QStyleOptionFrame opt;
        opt.initFrom(this);
        style()->drawPrimitive( QStyle::PE_Frame, &opt, painter, this);
    }
}
Example #13
0
File: main.c Project: stuydw/line
int main() {

  screen s;
  color c;
 
  
  c.red = 0;
  c.green = 0;
  c.blue = 0;
  
  clear_screen(s);

  int i, j;

  for (i=0; i < YRES; i++)
    for (j=0; j < XRES; j++ )
      plot(s, c, i, j);
  
   c.green = MAX_COLOR;
  draw_line(250, 0, 250, 500, s, c);
  draw_line(125, 0, 375, 500, s, c);
  draw_line(0, 0, 500, 500, s, c);
  draw_line(0, 125, 500, 375, s, c);
  draw_line(0, 250, 500, 250, s, c);
  draw_line(0, 375, 500, 125, s, c);
  draw_line(0, 500, 500, 0, s, c);
  draw_line(125, 500, 375, 0, s, c);

  /*  c.green = 0;
  c.red = MAX_COLOR;

  draw_line(125, 0, 125, 250, s, c);
  draw_line(62, 0, 187, 250, s, c);
  draw_line(0, 0, 250, 250, s, c);
  draw_line(0, 62, 250, 187, s, c);
  draw_line(0, 125, 250, 125, s, c);
  draw_line(0, 187, 250, 62, s, c);
  draw_line(0, 250, 250, 0, s, c);
  draw_line(62, 250, 187, 0, s, c);

  c.red = 0;
  c.blue = MAX_COLOR;

  draw_line(375, 0, 375, 250, s, c);
  draw_line(312, 0, 427, 250, s, c);
  draw_line(250, 0, 500, 250, s, c);
  draw_line(250, 62, 500, 187, s, c);
  draw_line(250, 125, 500, 125, s, c);
  draw_line(250, 187, 500, 62, s, c);
  draw_line(250, 250, 500, 0, s, c);
  draw_line(312, 250, 427, 0, s, c);

  c.red = MAX_COLOR;

  draw_line(125, 250, 125, 500, s, c);
  draw_line(62, 250, 187, 500, s, c);
  draw_line(0, 250, 250, 500, s, c);
  draw_line(0, 312, 250, 427, s, c);
  draw_line(0, 375, 500, 375, s, c);
  draw_line(0, 427, 250, 312, s, c);
  draw_line(0, 500, 250, 250, s, c);
  draw_line(62, 500, 187, 250, s, c);

  c.blue = 0;
  c.green = MAX_COLOR;

  draw_line(375, 250, 375, 500, s, c);
  draw_line(312, 250, 427, 500, s, c);
  draw_line(250, 500, 500, 250, s, c);
  draw_line(250, 312, 500, 427, s, c);
  draw_line(250, 375, 500, 375, s, c);
  draw_line(250, 427, 500, 312, s, c);
  draw_line(250, 250, 500, 500, s, c);
  draw_line(312, 500, 427, 250, s, c);
  */

  //Note: Display may not work on your system
  //save_ppm and save_extension should be fine
  //display(s);
  save_ppm(s, "pic.ppm");
  save_extension(s, "whatevs.png");
}  
Example #14
0
int main ()
{
#if defined(VISP_HAVE_DISPLAY)
  try {
    //Create a window with one graphic
    vpPlot plot(1);

    // Change the default font
    //plot.setFont("-misc-fixed-bold-r-semicondensed--0-0-75-75-c-0-iso8859-10");

    //The graphic contains 2 curves
    plot.initGraph(0,2);

    //Set the graphic parameters
    plot.setTitle(0, "First graphic");
    plot.setUnitX(0, "time (s)");
    plot.setUnitY(0, "y");
    plot.setUnitZ(0, "z");
    plot.setLegend(0,0, "y^2+z^2=1 and y(0) = 1");
    plot.setLegend(0,1, "y^2+z^2=1 and y(0) = -1");
    plot.setColor(0,0,vpColor::red);
    plot.setColor(0,1,vpColor::green);

    double x = 0;
    double y = 1;
    double z = 0 ;
    double dx = 0.08;
    double dy = 0.04;
    double zsign = 1.0;

    unsigned long iter = 0;

    std::cout << "Hit CTRL-C to or right mouse button to exit..." << std::endl;
    bool end = false;
    while( !end ) {
      if (iter < 300) {
        //y*y+z*z = 1
        if (fabs(y) < 1.0)
          z = sqrt(1.0-y*y);
        else z = 0;

        //Add points to the graphic
        if (plot.plot(0,0, x,  y,  z*zsign) == vpMouseButton::button3)
          end = true;
        if (plot.plot(0,1, x, -y, -z*zsign) == vpMouseButton::button3)
          end = true;

        x += dx;

        if (fabs(y) >= 1.0 )
          dy = -dy;
        y += dy;
        if (fabs(y) >= 1.0 )
          zsign = -zsign;
      }
      else {
        // Tip: to allows modifying the point of view with the mouse we
        // plot always the last point
        if (plot.plot(0,0, x, y,z*zsign) == vpMouseButton::button3)
          end = true;
        if (plot.plot(0,1, x, -y,-z*zsign) == vpMouseButton::button3)
          end = true;
      }
      iter ++;
    }
    return 0;
  }
  catch(vpException e) {
    std::cout << "Catch an exception: " << e << std::endl;
    return 1;
  }
#else
  std::cout << "Plot functionalities are not avalaible since no display is available." << std::endl;
#endif
}
Example #15
0
File: main.c Project: stuydw/matrix
int main() {

  screen s;
  color c;

  // TEST: add_point
  struct matrix *a;
  a = (struct matrix *)new_matrix(3,3);
  add_point(a,1,0,2);

  // TEST: print_matrix
  printf("\nAdding one point to matrix A:\n");
  print_matrix(a);
  
  //  TEST: add_edge
  add_edge(a,4,5,3,2,2,2);
  printf("Adding an edge:\n");
  print_matrix(a);

  // TEST: scalar multiplication
  scalar_mult(5,a);
  printf("Scalar multiplication by 5:\n");
  print_matrix(a);
  scalar_mult(0.2,a);
  printf("Scalar multiplication by 0.2, returning to original matrix:\n");
  print_matrix(a);

  // TEST: matrix matrix multiplication
  struct matrix *b;
  b = (struct matrix *)new_matrix(3,1);
  add_point(b,1,2,3);
  printf("Matrix B:\n");
  print_matrix(b);
  matrix_mult(a,b);
  printf("Matrix multiplication of A with B:\n");
  print_matrix(a);

  // TEST: turning a matrix into the identity matrix
  struct matrix *d;
  d = (struct matrix *)new_matrix(3,3);
  add_edge(d,3,4,5,8.2,9.1,2);
  add_point(d,5,2,1);
  printf("Matrix C:\n");
  print_matrix(d);
  ident(d);
  printf("Matrix C after being made into the 3 x 3 identity matrix:\n");
  print_matrix(d);

  /*
  struct matrix *m;
  m = (struct matrix *)new_matrix(3,3);
  m->m[0][0] = 1;
  m->m[0][1] = 2;
  m->m[0][2] = 5;
  m->m[1][0] = 3;
  m->m[1][1] = 4;
  m->m[1][2] = 6;
  m->m[2][0] = 7;
  m->m[2][1] = 8;
  m->m[2][2] = 9;
  */

  /*
  struct matrix *n;
  n = (struct matrix *)new_matrix(3,4);
  n->m[0][0] = 1;
  n->m[1][0] = 2;
  n->m[2][0] = 1;
  n->m[0][1] = 1;
  n->m[1][1] = 0;
  n->m[2][1] = 1;
  n->m[0][2] = 1;
  n->m[1][2] = 2;
  n->m[2][2] = 1;
  n->m[0][3] = 1;
  n->m[1][3] = 1;
  n->m[2][3] = 0;
  */
 
  /*
  struct matrix *p;
  p = (struct matrix *)new_matrix(3,5);
  p->m[0][0] = 1;
  //print_matrix(p);
  //print_matrix(matrix_mult(m,n));
  */

  /*
  struct matrix *q;
  q = (struct matrix *)new_matrix(3,2);
  add_point(q,0,0,0);
  add_point(q,100,0,0);

  struct matrix *t;
  t = (struct matrix *)new_matrix(3,3);
  t->m[0][0] = cos(M_PI / 6);
  t->m[1][0] = sin(M_PI / 6);
  t->m[0][1] = -1 * sin(M_PI / 6);
  t->m[1][1] = cos(M_PI / 6);
  t->lastcol = 2;
  */
  /*add_edge(t,cos( M_PI / 6),sin( M_PI / 6), 0,
	   -1 * sin(M_PI / 6), cos(M_PI / 6), 0);
  */

  /*
  struct matrix *u;
  u = (struct matrix *)new_matrix(3,2);
  add_edge(u,0,0,0,100,0,0);
  
  int i;
  for(i = 0; i < 11; i++){
    matrix_mult(t,q);
    add_edge(u,q->m[0][0],q->m[1][0],q->m[2][0],
	     q->m[0][1],q->m[1][1],q->m[2][1]);}
  int j,k;
  float f;
  for(j = 0; j < u->rows; j++){
    for(k = 0; k < u->cols; k++){
      f = u->m[j][k];
      u->m[j][k] = (int)f + 250;}
  }

  print_matrix(t);
  printf("%f\n", cos(M_PI / 6));
  */

  /*
  struct matrix *r;
  r = (struct matrix *)new_matrix(3,2);
  r->m[0][0] = 0;
  r->m[0][1] = 0;
  r->m[1][0] = 50;
  r->m[1][1] = 50;

  print_matrix(m);
  matrix_mult(m,q);
  print_matrix(m);
  */

  /*
  int i,j;
  c.red = 0;
  c.green = 0;
  c.blue = 255;
  for(i = 0; i < XRES; i++){
    for(j = 0; j < YRES; j++){
      plot(s,c,i,j);
    }
  }
  c.red = 0;
  c.green = 0;
  c.blue = 0;
  draw_lines(q,s,c);
  */

  /*
  int i, j;

  for( i=0; i<XRES; i++) 
    for ( j=0; j<YRES; j++) {

      c.red = random() % (MAX_COLOR + 1);
      c.green = random() % (MAX_COLOR + 1);
      c.blue = random() % (MAX_COLOR + 1);

      plot( s, c, i, j);
    }
  */

  c.red = 170;
  c.green = 240;
  c.blue = 30;

  int i,j;
  
  for(i = 0; i < XRES; i++){
    for(j = 0; j < YRES; j++){
      plot(s,c,i,j);
    }
  }

  // TEST: draw lines in edge matrix
  c.red = 0;
  c.green = 0;
  c.blue = 0;

  struct matrix *e;
  e = (struct matrix *)new_matrix(3,2);
  //add_point(e,0,0,0);
  //add_point(e,250,250,0);
  //draw_lines(e,s,c);
  for(i = 0; i < 25; i++){
    add_edge(e,250+5*i,250+5*i,0,500-5*i,250+5*i,0);
    add_edge(e,500-5*i,250+5*i,0,500-5*i,500-5*i,0);
    //add_edge(e,500-5*i,500-5*i,0,250+5*i,250+5*i,0);
  }
  for(i = 0; i < 25; i++){
    add_edge(e,5*i,5*i,0,250-5*i,5*i,0);
    add_edge(e,250-5*i,5*i,0,250-5*i,250-5*i,0);
    //add_edge(e,250-5*i,250-5*i,0,5*i,5*i,0);
  }
  for(i = 0; i < 25; i++){
    add_edge(e,125+5*i,125+5*i,0,125+5*i,375-5*i,0);
    add_edge(e,125+5*i,375-5*i,0,375-5*i,375-5*i,0);
    //add_edge(e,375-5*i,375-5*i,0,125+5*i,125+5*i,0);
  }
  add_edge(e,0,0,0,125,125,0);
  add_edge(e,375,375,0,500,500,0);
  draw_lines(e,s,c);

  display( s );    
  save_ppm(s,  "image" );
  save_extension(s, "image.jpg");  
  
}  
void LegendItem::paint(QPainter *painter) {
  if (!isVisible()) {
    return;
  }

  RelationList legendItems;
  if (_auto) {
    legendItems = plot()->renderItem(PlotRenderItem::Cartesian)->relationList();
  } else {
    legendItems = _relations;
  }

  int count = legendItems.count();
  if (count <= 0) { // no legend or box if there are no legend items
    return;
  }


  QList<DrawnLegendItem> legendPixmaps;
  QSize legendSize(0, 0);

  QFont font(_font);
  font.setPointSizeF(view()->viewScaledFontSize(_fontScale));

  // generate string list of relation names
  QStringList names;
  bool allAuto = true;
  bool sameX = true;
  bool sameYUnits = true;

  LabelInfo label_info = legendItems.at(0)->xLabelInfo();
  QString yUnits =  legendItems.at(0)->yLabelInfo().units;

  for (int i = 0; i<count; i++) {
    RelationPtr relation = legendItems.at(i);
    if (relation->descriptiveNameIsManual()) {
      allAuto = false;
    }
    if (relation->xLabelInfo() != label_info) {
      sameX = false;
    }
    // sameYUnits is false if any non empty units are defined differently.
    if (yUnits.isEmpty()) {
      yUnits = relation->yLabelInfo().units;
    } else if (relation->yLabelInfo().units != yUnits) {
      if (!relation->yLabelInfo().units.isEmpty()) {
        sameYUnits = false;
      }
    }
  }

  if (!allAuto) {
    for (int i = 0; i<count; i++) {
      names.append(legendItems.at(i)->descriptiveName());
    }
  } else {
    for (int i = 0; i<count; i++) {
      RelationPtr relation = legendItems.at(i);
      QString label = relation->titleInfo().singleRenderItemLabel();
      if (label.isEmpty()) {
        label_info = relation->yLabelInfo();
        QString y_label = label_info.name;
        if (!sameYUnits) {
          if (!label_info.units.isEmpty()) {
            y_label = i18n("%1 \\[%2\\]").arg(y_label).arg(label_info.units);
          }
        }
        if (!y_label.isEmpty()) {
          LabelInfo xlabel_info = relation->xLabelInfo();
          if (!sameX) {
            label = i18n("%1 vs %2").arg(y_label).arg(xlabel_info.name);
          } else if (xlabel_info.quantity.isEmpty()) {
            label = y_label;
          } else if (xlabel_info.quantity != xlabel_info.name) {
            label = i18n("%1 vs %2").arg(y_label).arg(xlabel_info.name);
          } else {
            label = y_label;
          }
        } else {
          label = relation->descriptiveName();
        }
      }
      int i_dup = names.indexOf(label);
      if (i_dup<0) {
        names.append(label);
      } else {
        RelationPtr dup_relation = legendItems.at(i_dup);
        if (!dup_relation->yLabelInfo().file.isEmpty()) {
          names.replace(i_dup, label + " (" + dup_relation->yLabelInfo().file + ')');
        }
        if (!relation->yLabelInfo().file.isEmpty()) {
          names.append(label + " (" + relation->yLabelInfo().file + ')');
        }
      }
    }
  }

  for (int i = 0; i<count; i++) {
    RelationPtr relation = legendItems.at(i);
    DrawnLegendItem item;
    item.pixmap = QPixmap(LEGENDITEMMAXWIDTH, LEGENDITEMMAXHEIGHT);
    item.size = paintRelation(names.at(i), relation, &item.pixmap, font);

    if (_verticalDisplay) {
      legendSize.setWidth(qMax(legendSize.width(), item.size.width()));
      legendSize.setHeight(legendSize.height() + item.size.height());
    } else {
      legendSize.setHeight(qMax(legendSize.height(), item.size.height()));
      legendSize.setWidth(legendSize.width() + item.size.width());
    }

    legendPixmaps.append(item);
  }

  int x = rect().left();
  int y = rect().top();

  painter->save();

  if (!_title.isEmpty()) {
    // Paint the title
    Label::Parsed *parsed = Label::parse(_title);

    if (parsed) {
      painter->save();

      QPixmap pixmap(400, 100);
      pixmap.fill(Qt::transparent);
      QPainter pixmapPainter(&pixmap);

      Label::RenderContext rc(font, &pixmapPainter);
      QFontMetrics fm(font);
      rc.y = fm.ascent();
      Label::renderLabel(rc, parsed->chunk, false);

      int startPoint = qMax(0, (legendSize.width() / 2) - (rc.x / 2));
      int paddingValue = fm.height() / 4;
    
      setViewRect(viewRect().x(), viewRect().y(), qMax(rc.x, legendSize.width()), rc.y + legendSize.height() + paddingValue * 3);
      painter->drawRect(rect());

      painter->drawPixmap(QPoint(x + startPoint, y + paddingValue), pixmap, QRect(0, 0, rc.x, fm.height()));
      painter->restore();
      y += fm.height() + (paddingValue *2);
      delete parsed;
      parsed = 0;
    }
  } else {
    // No Title
    setViewRect(viewRect().x(), viewRect().y(), legendSize.width(), legendSize.height());
    painter->drawRect(rect());
  }


  foreach(const DrawnLegendItem &item, legendPixmaps) {
    painter->drawPixmap(QPoint(x, y), item.pixmap, QRect(0, 0, item.size.width(), item.size.height()));
    if (_verticalDisplay) {
      y += item.size.height();
    } else {
      x += item.size.width();
    }
  }
Example #17
0
/**
 * Do setup for line rasterization, then render the line.
 * Single-pixel width, no stipple, etc.  We rely on the 'draw' module
 * to handle stippling and wide lines.
 */
void
sp_setup_line(struct setup_context *setup,
              const float (*v0)[4],
              const float (*v1)[4])
{
   int x0 = (int) v0[0][0];
   int x1 = (int) v1[0][0];
   int y0 = (int) v0[0][1];
   int y1 = (int) v1[0][1];
   int dx = x1 - x0;
   int dy = y1 - y0;
   int xstep, ystep;
   uint layer = 0;
   unsigned viewport_index = 0;

#if DEBUG_VERTS
   debug_printf("Setup line:\n");
   print_vertex(setup, v0);
   print_vertex(setup, v1);
#endif

   if (setup->softpipe->no_rast || setup->softpipe->rasterizer->rasterizer_discard)
      return;

   if (dx == 0 && dy == 0)
      return;

   if (!setup_line_coefficients(setup, v0, v1))
      return;

   assert(v0[0][0] < 1.0e9);
   assert(v0[0][1] < 1.0e9);
   assert(v1[0][0] < 1.0e9);
   assert(v1[0][1] < 1.0e9);

   if (dx < 0) {
      dx = -dx;   /* make positive */
      xstep = -1;
   }
   else {
      xstep = 1;
   }

   if (dy < 0) {
      dy = -dy;   /* make positive */
      ystep = -1;
   }
   else {
      ystep = 1;
   }

   assert(dx >= 0);
   assert(dy >= 0);
   assert(setup->softpipe->reduced_prim == PIPE_PRIM_LINES);

   setup->quad[0].input.x0 = setup->quad[0].input.y0 = -1;
   setup->quad[0].inout.mask = 0x0;
   if (setup->softpipe->layer_slot > 0) {
      layer = *(unsigned *)setup->vprovoke[setup->softpipe->layer_slot];
      layer = MIN2(layer, setup->max_layer);
   }
   setup->quad[0].input.layer = layer;

   if (setup->softpipe->viewport_index_slot > 0) {
      unsigned *udata = (unsigned*)setup->vprovoke[setup->softpipe->viewport_index_slot];
      viewport_index = sp_clamp_viewport_idx(*udata);
   }
   setup->quad[0].input.viewport_index = viewport_index;

   /* XXX temporary: set coverage to 1.0 so the line appears
    * if AA mode happens to be enabled.
    */
   setup->quad[0].input.coverage[0] =
   setup->quad[0].input.coverage[1] =
   setup->quad[0].input.coverage[2] =
   setup->quad[0].input.coverage[3] = 1.0;

   if (dx > dy) {
      /*** X-major line ***/
      int i;
      const int errorInc = dy + dy;
      int error = errorInc - dx;
      const int errorDec = error - dx;

      for (i = 0; i < dx; i++) {
         plot(setup, x0, y0);

         x0 += xstep;
         if (error < 0) {
            error += errorInc;
         }
         else {
            error += errorDec;
            y0 += ystep;
         }
      }
   }
   else {
      /*** Y-major line ***/
      int i;
      const int errorInc = dx + dx;
      int error = errorInc - dy;
      const int errorDec = error - dy;

      for (i = 0; i < dy; i++) {
         plot(setup, x0, y0);

         y0 += ystep;
         if (error < 0) {
            error += errorInc;
         }
         else {
            error += errorDec;
            x0 += xstep;
         }
      }
   }

   /* draw final quad */
   if (setup->quad[0].inout.mask) {
      clip_emit_quad(setup, &setup->quad[0]);
   }
}
Example #18
0
void DeJong::reseed(){
    clear();
    seed();
    plot(1);
}
Example #19
0
int main() {

  screen s;
  color c;
  int i, j; 
  
  c.red = 0;
  c.green = MAX_COLOR;
  c.blue = 0;
  
  clear_screen(s);

  /*
  //octant 1
  draw_line( 0, 0, XRES-1, YRES - 75, s, c);  
  //  draw_line( XRES-1, YRES - 75, 0, 0, s, c);  

  //octant 2
  draw_line( 0, 0, XRES - 75, YRES-1, s, c); 
  //octant 8
  draw_line( 0, YRES-1, XRES-1, 75, s, c);  
  //octant 7
  draw_line( 0, YRES-1, XRES - 75, 0, s, c);

  c.green = 0;
  c.blue = MAX_COLOR;
  //octant 5
  draw_line( XRES - 1, YRES - 1, 0, 75, s, c);
  //octant 6
  draw_line( XRES - 1, YRES -1, 75, 0, s, c);
  //octant 4
  draw_line( XRES - 1, 0, 0, YRES - 75, s, c);
  //octant 3
  draw_line( XRES - 1, 0, 75, YRES - 1, s, c);
  
  c.blue = 0;
  c.red = MAX_COLOR;
  //y = x, y = -x
  draw_line( 0, 0, XRES - 1, YRES - 1, s, c);
  draw_line( 0, YRES - 1, XRES - 1, 0, s, c);

  //horizontal, vertical line
  draw_line( 0, YRES / 2, XRES - 1, YRES / 2, s, c);
  draw_line( XRES / 2, 0, XRES / 2, YRES - 1, s, c);

  draw_coord(s, c);
  draw_border(s, c);
  */
  c.red = MAX_COLOR;
  c.green = 0;
  c.blue = 0;
  for ( i = 0; i < XRES; i+=6 ) {
    draw_line( XRES / 2, YRES / 2, i, 0, s, c );
    c.red = c.red - 3;
    c.green = c.green + 3;
  }

  c.red = 0;
  c.green = MAX_COLOR;
  for ( i = 0; i < YRES; i+=6 ) {
    draw_line( XRES / 2, YRES / 2, YRES, i, s, c );
    c.green = c.green - 3;
    c.blue = c.blue + 3;
  }

  c.green = 0;
  c.blue = MAX_COLOR;
  for (i = 0; i < XRES; i+=6 ) {
    draw_line( XRES / 2, YRES /2, XRES - i, YRES, s, c );
    c.blue = c.blue - 3;
    c.green += 3;
    c.red += 3;
  }

  c.blue = 0;
  for (i = 0; i < XRES; i+=6 ) {
    draw_line( XRES / 2, YRES /2, 0, YRES - i, s, c );
    c.green -= 3;
  }

  for ( i = 0; i < XRES; i++ ) {
    for ( j = 0; j < YRES; j++ ) {
      if ( i % 100 <= 3 || j % 100 <= 3 ) {
	c.red = MAX_COLOR;
	c.green = MAX_COLOR / 2 + 50;
	c.blue = MAX_COLOR;
	plot (s, c, i, j);
      }
    }
  }

  for ( i = 0; i < XRES; i+=10 ) {
    c.red = 0;
    c.green = 0;
    c.blue = 0;
    draw_line( i, 0, 0, i, s, c );
    draw_line( i, 0, YRES - i, XRES, s, c );
    draw_line( 0, i, XRES, YRES - i, s, c );
  }

  draw_border(s, c);

  save_extension(s, "lines.png");  
  display(s);

}  
Example #20
0
File: draw.c Project: stuydw/matrix
void draw_line(int x0, int y0, int x1, int y1, screen s, color c) {
 
  int x, y, dx, dy, d, A, B;
  x = x0;
  y = y0;
  //swap values if octants 3-6
  if ( x0 > x1 ) {
    x = x1;
    y = y1;
    x1 = x0;
    y1 = y0;
  }

  dx = x1 - x;
  dy = y1 - y;
  A = dy * 2;
  B = -2 * dx;
    
  //positive slope: Octants 1,2
  if ( dy > 0 ) {

    //Octant 1
    if ( dx > dy ) {
      
      d = A + B/2;
      while ( x <= x1 ) {
	plot( s, c, x, y );
	if ( d > 0 ) {
	  y++;
	  d+= B;
	}
	x++;
	d+= A;
      }
    }// end octant 1

    //Octant 2
    else {
      
      d = A/2 + B;
      while ( y <= y1 ) {
	plot( s, c, x, y );
	if ( d < 0 ) {
	  x++;
	  d+=A;
	}
	y++;
	d+= B;
      }
    }//Octant 2
  }//octants: 1, 2
  
  //negative slope: Octants: 7, 8
  else {
    //Octant 8
    if ( dx > (-1 * dy) ) {
      d = A - B/2;
      while ( x <= x1 ) {
	plot(s, c, x, y);
	if ( d < 0 ) {
	  y--;
	  d-=B;
	}
	x++;
	d+= A;
      }
    }//end octant 8
    
    //octant 7
    else {
      d = A/2 - B;
      while( y >= y1 ) {
	plot(s, c, x, y);
	if ( d > 0 ) {
	  x++;
	  d+= A;
	}
	y--;
	d-= B;
      }
    } //end octant 7
  }//end Octants 7,8
}
Example #21
0
graph (struct s_record r[])
{
int i, j;
long max, max_d;
char buf[200];
	if (!strncmp (buf, "CARBONE", 7))
		break_debug();
	/* printf ("%s", r[0].nom); */
	sprintf (buf, "%s", r[0].nom);
#ifdef TEST
#else
#ifdef LOWLEVEL
#else
/*	if (strncmp (buf, "SOPRA", 5)) */
	outtextxy (1, 1, buf);
#endif
#endif
	if (!strcmp (r[0].nom, "CARBONE LORRAINE"))
		restorecrtmode();

	max = 0;
        for (i=0; r[i].status; i++)
        {
                if (r[i].clot > max)
                        max = r[i].clot;
        }
        max_d = 0;
        for (i=1; r[i].status; i++)
        {
                if (r[i].dl > max_d)
                        max_d = r[i].dl;
                if (-r[i].dl > max_d)
                        max_d = -r[i].dl;
        }
        if (max == 0)
                max = 1;
        if (max_d == 0)
                max_d = 1;
        for (i=0; r[i].status; i++)
        {
                plot (i*10, HAUT + BAS - r[i].clot * BAS / max, 15);
                plot (i*10, AXE_X - r[i].dl * AXE_X / max_d / DIV_D, 15);
        }
        for (i=0; r[i+1].status; i++)
        {
                /* plot (i*4, 100-r[i].clot / 100, 1); */
                /* plot (i*10, 800 - r[i].clot, 15); */
                for (j=0; j<=N; j++)
                {
                        plot (i*10+j, HAUT + BAS - (r[i].l * (N-j) + r[i+1].l * j) / N * BAS / max, 7);
                        plot (XD0 + (r[i].dl * (N-j) + r[i+1].dl * j) * AXE_X / N / max_d / DIV_D,
                              HAUT + BAS - (r[i].l * (N-j) + r[i+1].l * j) / N * BAS / max, 7);
                        /*
                        plot (i*10+j, BAS - (r[i].dl * (N-j) + r[i+1].dl * j) / N * BAS / max, 6);
                        plot (i*10+j, BAS - (r[i].ldl * (N-j) + r[i+1].ldl * j) / N * BAS / max, 5);
                        */
                        plot (i*10+j, AXE_X, 6);
                        /* plot (i*10+j, AXE_X - (r[i].dl * (N-j) + r[i+1].dl * j) / N * AXE_X / max_d , 15); */
                        plot (i*10+j, AXE_X - (r[i].ldl * (N-j) + r[i+1].ldl * j) * AXE_X / N / max_d / DIV_D, 7);

                }
                /* printf ("%d\n", r[i].clot); */
                /* printf ("%d %d %d %d\n", r[i].clot, r[i].l, r[i].dl, r[i].ldl);  */
	}
	/*
	if (!strcmp (r[0].nom, "CARBONE LORRAINE"))
		restorecrtmode();
	*/

}
Example #22
0
void SARRERA_pantailenAukerak(int x, int y, int zabalera, int altuera, int pantailaKopurua){
	//aldagaiak
	int i = 0, t = 0;

	//programa

	borraCopiaPantalla();
	for (i = y; i < y + altuera; i++){
		for (t = x; t < x + zabalera; t++){
			plot(t, i, URDINA_FONDO);
		}
	}
	if (pantailaKopurua == 1){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, EXIT);
	}
	if (pantailaKopurua == 2){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, AUKERA1);
		escribirTexto(150, 250, EXIT);
	}
	if (pantailaKopurua == 3){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, AUKERA1);
		escribirTexto(150, 250, AUKERA2);
		escribirTexto(150, 300, EXIT);
	}
	if (pantailaKopurua == 4){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, AUKERA1);
		escribirTexto(150, 250, AUKERA2);
		escribirTexto(150, 300, AUKERA3);
		escribirTexto(150, 350, EXIT);
	}
	if (pantailaKopurua == 5){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, AUKERA1);
		escribirTexto(150, 250, AUKERA2);
		escribirTexto(150, 300, AUKERA3);
		escribirTexto(150, 350, AUKERA4);
		escribirTexto(150, 400, EXIT);
	}
	if (pantailaKopurua == 6){
		escribirTexto(225, 50, TITULOA);
		escribirTexto(150, 150, AUKERA0);
		escribirTexto(150, 200, AUKERA1);
		escribirTexto(150, 250, AUKERA2);
		escribirTexto(150, 300, AUKERA3);
		escribirTexto(150, 350, AUKERA4);
		escribirTexto(150, 400, AUKERA5);
		escribirTexto(150, 450, EXIT);
	}
	if (pantailaKopurua == 7){

	}
	actualizaPantalla();
}
int main()
{
   Plotdata x(-3.0, 3.0), y = sin(x) - 0.5*x;
   plot(x, y);
   return 0;
}
void drawLine(sf::RenderTarget& target, float x1, float y1, float x2, float y2, const sf::Color& color)
{
    float dx = x2 - x1;
    float dy = y2 - y1;

    // Store all points in an arrry
    sf::VertexArray va(sf::Points);

    if (std::fabs(dx) > std::fabs(dy))
    {
        if(x2 < x1)
        {
            std::swap(x1, x2);
            std::swap(y1, y2);
        }

        float gradient = dy / dx;
        float xend = static_cast<float>(round(x1));
        float yend = y1 + gradient * (xend - x1);
        float xgap = rfpart(x1 + 0.5f);

        int xpxl1 = static_cast<int>(xend);
        int ypxl1 = ipart(yend);

        // Add the first endpoint
        plot(va, xpxl1, ypxl1, rfpart(yend) * xgap, color);
        plot(va, xpxl1, ypxl1 + 1, fpart(yend) * xgap, color);

        float intery = yend + gradient;

        xend = static_cast<float>(round(x2));
        yend = y2 + gradient * (xend - x2);
        xgap = fpart(x2 + 0.5f);

        int xpxl2 = static_cast<int>(xend);
        int ypxl2 = ipart(yend);

        // Add the second endpoint
        plot(va, xpxl2, ypxl2, rfpart(yend) * xgap, color);
        plot(va, xpxl2, ypxl2 + 1, fpart(yend) * xgap, color);

        // Add all the points between the endpoints
        for(int x = xpxl1 + 1; x <= xpxl2 - 1; ++x)
        {
            plot(va, x, ipart(intery), rfpart(intery), color);
            plot(va, x, ipart(intery) + 1, fpart(intery), color);
            intery += gradient;
        }
    }
    else
    {
        if(y2 < y1)
        {
            std::swap(x1, x2);
            std::swap(y1, y2);
        }

        float gradient = dx / dy;
        float yend = static_cast<float>(round(y1));
        float xend = x1 + gradient * (yend - y1);
        float ygap = rfpart(y1 + 0.5f);

        int ypxl1 = static_cast<int>(yend);
        int xpxl1 = ipart(xend);

        // Add the first endpoint
        plot(va, xpxl1, ypxl1, rfpart(xend) * ygap, color);
        plot(va, xpxl1, ypxl1 + 1, fpart(xend) * ygap, color);

        float interx = xend + gradient;

        yend = static_cast<float>(round(y2));
        xend = x2 + gradient * (yend - y2);
        ygap = fpart(y2 + 0.5f);

        int ypxl2 = static_cast<int>(yend);
        int xpxl2 = ipart(xend);

        // Add the second endpoint
        plot(va, xpxl2, ypxl2, rfpart(xend) * ygap, color);
        plot(va, xpxl2, ypxl2 + 1, fpart(xend) * ygap, color);

        // Add all the points between the endpoints
        for(int y = ypxl1 + 1; y <= ypxl2 - 1; ++y)
        {
            plot(va, ipart(interx), y, rfpart(interx), color);
            plot(va, ipart(interx) + 1, y, fpart(interx), color);
            interx += gradient;
        }
    }

    target.draw(va);
}
Example #25
0
int main(int argc, char **argv) {

	int xx,yy,ch,i;
	double theta,delta=0.0;


	grsim_init();
	gr();

//	clear_screens();

	ram[DRAW_PAGE]=PAGE0;
	clear_bottom();
	ram[DRAW_PAGE]=PAGE1;
	clear_bottom();
	ram[DRAW_PAGE]=PAGE2;
	clear_bottom();


//	clear_bottom(PAGE0);
//	clear_bottom(PAGE1);
//	clear_bottom(PAGE2);

//	grsim_unrle(demo_rle,0x400);
//	grsim_unrle(demo_rle,0xc00);

//	gr_copy_to_current(0xc00);
//	page_flip();
//	gr_copy_to_current(0xc00);
//	page_flip();

	ram[DRAW_PAGE]=PAGE0;

	while(1) {

		ch=repeat_until_keypressed();
		if (ch=='q') break;

		clear_top();

		for(theta=0;theta<360.0;theta+=STEP) {
			xx=cos(d2r(theta+delta))*SCALE+20;
			yy=sin(d2r(theta+delta))*SCALE*1.33+24;

#if 1
			color_equals(15);
			plot(xx,yy);

			if (xx<20) {
				color_equals(1);
				for(i=xx;i<(20-xx)+20;i++) {
					plot(i,yy);
				}
			}
			else {
				color_equals(2);
				for(i=xx;i<40;i++) {
					plot(i,yy);
				}
			}

#endif

#if 0
			color_equals(4);
			plot(xx,yy);
			if (xx>20) {
				for(i=xx;i<40;i++) {
					plot(i,yy);
				}
			}
#endif
#if 0

			color_equals(4);
//			plot(xx,yy);
			if (xx<20) {
				for(i=xx;i<40;i++) {
					plot(i,yy);
				}
			}
#endif

		}
		delta+=DELTA;

		grsim_update();

	}


	return 0;
}
Example #26
0
/* plot_point
 *
 * Plot a point given in window coordinates.
 */
void canvashdl::plot_point(vec3f v, vector<float> varying)
{
	plot((vec3i)v, varying);
}
Example #27
0
void QtDensity::getKernel(int kernel) {
    if (kernel != m_kernel) {
        m_kernel = kernel;
        plot();
    }
}
Example #28
0
/* plot_half_triangle
 *
 * Plot half of a triangle defined by three points in window coordinates (v1, v2, v3).
 * The remaining inputs are as follows (s1, s2, s3) are the pixel coordinates of (v1, v2, v3),
 * and (ave) is the average value of the normal and texture coordinates for flat shading.
 * Use Bresenham's algorithm for this. You may plot the horizontal half or the vertical half.
 */
void canvashdl::plot_half_triangle(vec3i s1, vector<float> v1_varying, vec3i s2, vector<float> v2_varying, vec3i s3, vector<float> v3_varying, vector<float> ave_varying)
{
	int b12 = (abs(s2[1] - s1[1]) > abs(s2[0] - s1[0]));
	int b13 = (abs(s1[1] - s3[1]) > abs(s1[0] - s3[0]));

	vec2i dv12 = s2 - s1;
	vec2i dv13 = s3 - s1;

	vec2i step12, step13;
	for (int i = 0; i < 2; i++)
	{
		step12[i] = (int)(dv12[i] > 0) - (int)(dv12[i] < 0);
		dv12[i] *= step12[i];
		step13[i] = (int)(dv13[i] > 0) - (int)(dv13[i] < 0);
		dv13[i] *= step13[i];
	}

	int D12 = 2*dv12[1-b12] - dv12[b12];
	int D13 = 2*dv13[1-b13] - dv13[b13];

	vector<float> varying12(v1_varying.size());
	vector<float> varying13(v1_varying.size());
	vector<float> varying12_diff(v1_varying.size());
	vector<float> varying13_diff(v1_varying.size());
	vector<float> varying_diff(v1_varying.size());

	if (shade_model != flat)
	{
		for (int i = 0; i < (int)v1_varying.size(); i++)
		{
			varying12_diff[i] = v2_varying[i] - v1_varying[i];
			varying13_diff[i] = v3_varying[i] - v1_varying[i];
		}
	}
	else
	{
		varying12 = v1_varying;
		varying13 = v1_varying;
	}

	plot(s1, v1_varying);

	vec3i p12 = s1, p13 = s1;
	float increment12 = (float)step12[b12]/(float)(s2[b12] - s1[b12]);
	float increment13 = (float)step13[b13]/(float)(s3[b13] - s1[b13]);
	float interpolate12 = 0.0f;
	float interpolate13 = 0.0f;
	while (step12[b12] != 0 && step13[b13] != 0 && step12[b12]*p12[b12] < step12[b12]*s2[b12] && step13[b13]*p13[b13] < step13[b13]*s3[b13])
	{
		vec2i old = p12;
		do
		{
			if (D12 > 0)
			{
				p12[1-b12] += step12[1-b12];
				D12 += 2*(dv12[1-b12] - dv12[b12]);
			}
			else
				D12 += 2*dv12[1-b12];

			p12[b12] += step12[b12];
			interpolate12 += increment12;
		} while ((step12[b12] != 0 || step12[1-b12] != 0) && (vec2i)p12 == old && step12[b12]*p12[b12] < step12[b12]*s2[b12]);

		while ((step13[b13] != 0 || step13[1-b13] != 0) && p13[0] != p12[0] && step13[b13]*p13[b13] < step13[b13]*s3[b13])
		{
			p13[b13] += step13[b13];
			interpolate13 += increment13;

			if (D13 > 0)
			{
				p13[1-b13] += step13[1-b13];
				D13 += 2*(dv13[1-b13] - dv13[b13]);
			}
			else
				D13 += 2*dv13[1-b13];
		}

		p12[2] = (int)((float)(s2[2] - s1[2])*interpolate12 + (float)s1[2]);
		p13[2] = (int)((float)(s3[2] - s1[2])*interpolate13 + (float)s1[2]);

		if (shade_model != flat)
		{
			for (int i = 0; i < (int)v1_varying.size(); i++)
			{
				varying12[i] = varying12_diff[i]*interpolate12 + v1_varying[i];
				varying13[i] = varying13_diff[i]*interpolate13 + v1_varying[i];
			}
		}

		vec3i Ai = p12;
		vec3i Bi = p13;

		if (Ai[1] > Bi[1])
		{
			swap(varying12, varying13);
			swap(Ai, Bi);
		}

		vec3i p = Ai;
		float increment = 1.0f/(float)(Bi[1] - Ai[1]);
		float interpolateab = 0.0f;

		if (shade_model != flat)
			for (int i = 0; i < (int)varying12.size(); i++)
				varying_diff[i] = varying13[i] - varying12[i];

		float zdiff = (float)(Bi[2] - Ai[2]);

		for (; p[1] < Bi[1]; p[1]++)
		{
			p[2] = (int)(zdiff*interpolateab) + Ai[2];

			if (shade_model != flat)
				for (int i = 0; i < (int)varying12.size(); i++)
					ave_varying[i] = varying_diff[i]*interpolateab + varying12[i];

			plot(p, ave_varying);
			interpolateab += increment;
		}
		plot(Bi, varying13);
	}
}
Example #29
0
File: draw.c Project: stuydw/3d
void draw_line(int x0, int y0, int x1, int y1, screen s, color c) {
 
  int x, y, d, dx, dy;

  x = x0;
  y = y0;
  
  //swap points so we're always draing left to right
  if ( x0 > x1 ) {
    x = x1;
    y = y1;
    x1 = x0;
    y1 = y0;
  }

  //need to know dx and dy for this version
  dx = (x1 - x) * 2;
  dy = (y1 - y) * 2;

  //positive slope: Octants 1, 2 (5 and 6)
  if ( dy > 0 ) {

    //slope < 1: Octant 1 (5)
    if ( dx > dy ) {
      d = dy - ( dx / 2 );
  
      while ( x <= x1 ) {
	plot(s, c, x, y);

	if ( d < 0 ) {
	  x = x + 1;
	  d = d + dy;
	}
	else {
	  x = x + 1;
	  y = y + 1;
	  d = d + dy - dx;
	}
      }
    }

    //slope > 1: Octant 2 (6)
    else {
      d = ( dy / 2 ) - dx;
      while ( y <= y1 ) {

	plot(s, c, x, y );
	if ( d > 0 ) {
	  y = y + 1;
	  d = d - dx;
	}
	else {
	  y = y + 1;
	  x = x + 1;
	  d = d + dy - dx;
	}
      }
    }
  }

  //negative slope: Octants 7, 8 (3 and 4)
  else { 

    //slope > -1: Octant 8 (4)
    if ( dx > abs(dy) ) {

      d = dy + ( dx / 2 );
  
      while ( x <= x1 ) {

	plot(s, c, x, y);

	if ( d > 0 ) {
	  x = x + 1;
	  d = d + dy;
	}
	else {
	  x = x + 1;
	  y = y - 1;
	  d = d + dy + dx;
	}
      }
    }

    //slope < -1: Octant 7 (3)
    else {

      d =  (dy / 2) + dx;

      while ( y >= y1 ) {
	
	plot(s, c, x, y );
	if ( d < 0 ) {
	  y = y - 1;
	  d = d + dx;
	}
	else {
	  y = y - 1;
	  x = x + 1;
	  d = d + dy + dx;
	}
      }
    }
  }
}
int
main(int argc, char const **argv)
{
    // Initialise ncurses
    WINDOW* win = nullptr;
    if ((win = initscr()) == nullptr) {
        std::cerr << "failed to initialize ncurses\n";
        return 1;
    }

    // Check for colors.
    if (!has_colors()) {
        delwin(win);
        endwin();
        refresh();
        std::cerr << "your terminal doesn't support colors\n";
        return 1;
    }

    noecho();
    keypad(win, true);
    start_color();
    use_default_colors();

    // Color pairs
    init_pair(1, COLOR_WHITE, COLOR_BLACK);
    init_pair(2, COLOR_RED, COLOR_BLACK);
    init_pair(3, COLOR_YELLOW, COLOR_BLACK);
    init_pair(4, COLOR_GREEN, COLOR_BLACK);
    init_pair(5, COLOR_CYAN, COLOR_BLACK);
    init_pair(6, COLOR_BLUE, COLOR_BLACK);
    init_pair(7, COLOR_MAGENTA, COLOR_BLACK);

    // Width must be a multiple of 8 for AVX.
    u32 const w = COLS - (COLS % 8);

    // Leave one line for printing timing info.
    u32 const h = LINES - 1;

    // Initial center point
    float cx = 0.0f;
    float cy = 0.0f;

    // Compute size of area viewable
    float sx = 2.7f;
    float sy = -4.0f / 3.0f * 2.7f * (float) h / (float) w;

    // Compute corner points
    float x1 = cx - sx / 2.0f;
    float y1 = cy - sy / 2.0f;
    float x2 = cx + sx / 2.0f;
    float y2 = cy + sy / 2.0f;

    // Compute deltas
    float dx = (x2 - x1) / (float) w;
    float dy = (y2 - y1) / (float) h;

    // Main loop
    bool running = true;
    bool dirty   = true;
    while (running) {
        if (dirty) {
            // Recompute corner points
            x1 = cx - sx / 2.0f;
            y1 = cy - sy / 2.0f;
            x2 = cx + sx / 2.0f;
            y2 = cy + sy / 2.0f;

            // Recompute deltas
            dx = (x2 - x1) / (float) w;
            dy = (y2 - y1) / (float) h;

            clear();
            plot(w, h, x1, y1, x2, y2, dx, dy);
            refresh();

            dirty = false;
        }

        // Check for keyboard input
        u32 input = getch();
        switch (input) {

        // Quit
        case 'q':
            running = false;
            break;

        // Move
        case KEY_LEFT:
            cx -= 5.0f * dx;
            dirty = true;
            break;
        case KEY_RIGHT:
            cx += 5.0f * dx;
            dirty = true;
            break;
        case KEY_UP:
            cy -= 5.0f * dy;
            dirty = true;
            break;
        case KEY_DOWN:
            cy += 5.0f * dy;
            dirty = true;
            break;

        // Zoom
        case '-':
            sx *= 1.1f;
            sy *= 1.1f;
            dirty = true;
            break;
        case '=':
            sx /= 1.1f;
            sy /= 1.1f;
            dirty = true;
            break;
        }
    }

    // Kill ncurses
    delwin(win);
    endwin();
    refresh();

    return 0;
}