Example #1
0
dPoint
Conv::units_bck(dPoint p) const{
  dPoint p1 = p + dPoint(1,0);
  dPoint p2 = p + dPoint(0,1);
  bck(p), bck(p1), bck(p2);
  return dPoint(pdist(p1-p), pdist(p2-p));
}
Example #2
0
double
Conv::ang_bck(dPoint p, double a, double dx) const{
  dPoint p1 = p + dPoint(dx*cos(a), dx*sin(a));
  dPoint p2 = p - dPoint(dx*cos(a), dx*sin(a));
  bck(p1); bck(p2);
  p1-=p2;
  return atan2(p1.y, p1.x);
}
Example #3
0
void
PageBox::ch_page() {
    if (no_ch) return;
    dPoint p = page->get_active_id();
    if (p.x==0) {
        signal_changed_.emit();
        return;
    }

    double d = dpi->get_value();

    // convert margins to mm
    double m = marg->get_value() *
               u2mm(m_units->get_active_id(),d);
    p-=2*dPoint(m,m);
    if (p.x<0) p.x=0;
    if (p.y<0) p.y=0;

    // convert p to interface units:
    p/=u2mm(units->get_active_id(),d);

    bool sw = landsc->get_active();
    no_ch=true;
    x->set_value(sw? p.y:p.x);
    y->set_value(sw? p.x:p.y);
    no_ch=false;
    signal_changed_.emit();
}
vector<cv::Point> ImageTransformation::getPointsRandomTransformation(vector<cv::Point> iP, Mat_<float> mx, Mat_<float> my)
{
    vector<Point> iiP;

    for(int i = 0; i < iP.size(); ++i)
    {
        int x = mx(iP[i].x,iP[i].y);
        int y = my(iP[i].x,iP[i].y);
//        qDebug()<< "x:" << iP[i].x << "to" << x;
//        qDebug()<< "y:" << iP[i].y << "to" << y;
        Point dPoint(x,y);
        iiP.push_back(dPoint);
    }

    return iiP;
}
QPointF KisCoordinatesConverter::centeringCorrection() const
{
    KisConfig cfg;

    QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size();
    QPointF dPoint(documentSize.width(), documentSize.height());
    QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height());

    QPointF minOffset = -cfg.vastScrolling() * wPoint;
    QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint;

    QPointF range = maxOffset - minOffset;

    range.rx() = qMin(range.x(), (qreal)0.0);
    range.ry() = qMin(range.y(), (qreal)0.0);

    range /= 2;

    return -range;
}
Example #6
0
bool Cube::intersect(Vertex p, Vect d, vector<Shape *> * intersects){
	Vertex dPoint(d.x, d.y, d.z);
	translate(-trans[0], -trans[1], -trans[2], &p);		
	rotate(-rot[2], 0, 0 , 1, &p);
	rotate(-rot[1], 0, 1 , 0, &p);
	rotate(-rot[0], 1, 0 , 0, &p);

	rotate(-rot[2], 0, 0 , 1, &dPoint);
	rotate(-rot[1], 0, 1 , 0, &dPoint);
	rotate(-rot[0], 1, 0 , 0, &dPoint);
	
	scale(1/scal[0], 1/scal[1], 1/scal[2], &p);
	scale(1/scal[0], 1/scal[1], 1/scal[2], &dPoint);

	d.x = dPoint.x;
	d.y = dPoint.y;
	d.z = dPoint.z;

	//Vect * newD = Vect::unitVector(d);
		
	return intersectUnit(p,d, intersects);	
}
Example #7
0
dLine
Conv::line_frw(const dLine & l, double acc, int max) const {
  dLine ret;
  if (l.size()==0) return ret;
  dPoint P1 = l[0], P1a =P1;
  frw(P1a); ret.push_back(P1a); // add first point
  dPoint P2, P2a;

  for (int i=1; i<l.size(); i++){
    P1 = l[i-1];
    P2 = l[i];
    double d = pdist(P1-P2)/(max+1)*1.5;
    do {
      P1a = P1; frw(P1a);
      P2a = P2; frw(P2a);
      // C1 - is a center of (P1-P2)
      // C2-C1 is a perpendicular to (P1-P2) with acc length
      dPoint C1 = (P1+P2)/2.;
      dPoint C2 = C1 + acc*pnorm(dPoint(P1.y-P2.y, -P1.x+P2.x));
      dPoint C1a = C1; frw(C1a);
      dPoint C2a = C2; frw(C2a);
      if ((pdist(C1a, (P1a+P2a)/2.) < pdist(C1a,C2a)) ||
          (pdist(P1-P2) < d)){
        // go to the rest of line (P2-l[i])
        ret.push_back(P2a);
        P1 = P2;
        P2 = l[i];
      }
      else {
        // go to the first half (P1-C1) of current line
        P2 = C1;
      }
    } while (P1!=P2);
  }
  return ret;
}
bool KisZoomAndPanTest::checkRotation(ZoomAndPanTester &t, qreal angle)
{
    // save old values
    QPoint oldOffset = t.coordinatesConverter()->documentOffset();
    QPointF oldCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
    QPointF oldPreferredCenter = t.canvasController()->preferredCenter();
    QPointF oldRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
    QSize oldDocumentSize = t.canvasController()->documentSize();

    qreal baseAngle = t.coordinatesConverter()->rotationAngle();
    t.canvasController()->rotateCanvas(angle);

    // save result values
    QPoint newOffset = t.coordinatesConverter()->documentOffset();
    QPointF newCenteringCorrection = t.coordinatesConverter()->centeringCorrection();
    QPointF newPreferredCenter = t.canvasController()->preferredCenter();
    QPointF newRealCenterPoint = t.coordinatesConverter()->widgetToImage(t.coordinatesConverter()->widgetCenterPoint());
    QSize newDocumentSize = t.canvasController()->documentSize();


    // calculate theoretical preferred center
    QTransform rot;
    rot.rotate(angle);

    QSizeF dSize = t.coordinatesConverter()->imageSizeInFlakePixels();
    QPointF dPoint(dSize.width(), dSize.height());

    QPointF expectedPreferredCenter =
        (oldPreferredCenter - dPoint * correctionMatrix(baseAngle)) * rot +
         dPoint * correctionMatrix(baseAngle + angle);

    // calculate theoretical offset based on the real preferred center
    QPointF wPoint(t.canvasWidget()->size().width(), t.canvasWidget()->size().height());
    QPointF expectedOldOffset = oldPreferredCenter - 0.5 * wPoint;
    QPointF expectedNewOffset = newPreferredCenter - 0.5 * wPoint;

    bool preferredCenterAsExpected =
        compareWithRounding(expectedPreferredCenter, newPreferredCenter, 2);
    bool oldOffsetAsExpected =
        compareWithRounding(expectedOldOffset + oldCenteringCorrection, QPointF(oldOffset), 2);
    bool newOffsetAsExpected =
        compareWithRounding(expectedNewOffset + newCenteringCorrection, QPointF(newOffset), 3);

    qreal zoom = t.zoomController()->zoomAction()->effectiveZoom();
    bool realCenterPointAsExpected =
        compareWithRounding(oldRealCenterPoint, newRealCenterPoint, 2/zoom);


    if (!oldOffsetAsExpected ||
        !newOffsetAsExpected ||
        !preferredCenterAsExpected ||
        !realCenterPointAsExpected) {

        qDebug() << "***** ROTATE **************";

        if(!oldOffsetAsExpected) {
            qDebug() << " ### Old offset invariant broken";
        }

        if(!newOffsetAsExpected) {
            qDebug() << " ### New offset invariant broken";
        }

        if(!preferredCenterAsExpected) {
            qDebug() << " ### Preferred center invariant broken";
        }

        if(!realCenterPointAsExpected) {
            qDebug() << " ### *Real* center invariant broken";
        }

        qDebug() << ppVar(expectedOldOffset);
        qDebug() << ppVar(expectedNewOffset);
        qDebug() << ppVar(expectedPreferredCenter);
        qDebug() << ppVar(oldOffset) << ppVar(newOffset);
        qDebug() << ppVar(oldCenteringCorrection) << ppVar(newCenteringCorrection);
        qDebug() << ppVar(oldPreferredCenter) << ppVar(newPreferredCenter);
        qDebug() << ppVar(oldRealCenterPoint) << ppVar(newRealCenterPoint);
        qDebug() << ppVar(oldDocumentSize) << ppVar(newDocumentSize);
        qDebug() << ppVar(baseAngle) << "deg";
        qDebug() << ppVar(angle) << "deg";
        qDebug() << "***************************";
    }

    return preferredCenterAsExpected && oldOffsetAsExpected && newOffsetAsExpected && realCenterPointAsExpected;
}
Example #9
0
dPoint
PageBox::get_px() {
    double f = u2px(units->get_active_id(), dpi->get_value());
    return dPoint(x->get_value(), y->get_value()) * f;
}
Example #10
0
int
GObjGridPulk::draw(iImage & image, const iPoint & origin){

  /* find wgs coordinate range and 6 degree zones */
  const g_map m = *get_ref();
  dPoint dorg(origin);
  dRect rng = image.range() + dorg;
  dRect rng_wgs = cnv.bb_frw(rng); // screen -> wgs
  int lon0a = convs::lon2lon0(rng_wgs.TLC().x);
  int lon0b = convs::lon2lon0(rng_wgs.BRC().x);

  /* for all zones */
  for (int lon0=lon0a; lon0<=lon0b; lon0+=6){

    /* build  screen -> pulkovo conversion or get it from the cache */
    if (!convs.contains(lon0)){
      Options o;
      o.put("lon0", lon0);
      convs.add(lon0, convs::map2pt(m, Datum("pulk"), Proj("tmerc"), o));
    }
    convs::map2pt cnv1(convs.get(lon0));

    dRect rng_pulk = cnv1.bb_frw(rng); // screen -> pulkovo
    if (std::isinf(rng_pulk.w) || std::isinf(rng_pulk.w)) continue;
    double step = 1000;
    while (rng_pulk.w> step*10 || rng_pulk.h> step*10) step*=10.0;
    while (rng_pulk.w< step/10 || rng_pulk.h< step/10) step/=10.0;

    dPoint tlc = rng_pulk.TLC(), brc= rng_pulk.BRC();
    double xmin = floor(tlc.x/step)*step;
    double xmax = ceil(brc.x/step)*step;
    double ymin = floor(tlc.y/step)*step;
    double ymax = ceil(brc.y/step)*step;

    CairoWrapper cr(image);
    cr->set_source_rgba(1,0,0,1);
    cr->set_line_width(2);
    if (lon0a!=lon0b){ /* clip the zone */
      dRect rng_clip(lon0-3.0, rng_wgs.y, 6.0, rng_wgs.h);
      rng_wgs.y-=rng_wgs.h*0.2;
      rng_wgs.h+=rng_wgs.h*0.4;
      cr->mkpath(cnv.line_bck(rect2line(rng_clip,1)) - dorg);
      cr->clip_preserve();
      cr->stroke();
    }

    for (double x=xmin; x<=xmax; x+=step){
      dPoint p1(x, tlc.y), p2(x, brc.y);
      cnv1.bck(p1), cnv1.bck(p2);
      cr->move_to(p1-dorg);
      cr->line_to(p2-dorg);
    }
    for (double y=ymin; y<=ymax; y+=step){
      dPoint p1(tlc.x, y), p2(brc.x, y);
      cnv1.bck(p1), cnv1.bck(p2);
      cr->move_to(p1-dorg);
      cr->line_to(p2-dorg);
    }
    cr->stroke();

    /* step for labels */
    step*=2;
    xmin = floor(tlc.x/step)*step;
    xmax = ceil(brc.x/step)*step;
    ymin = floor(tlc.y/step)*step;
    ymax = ceil(brc.y/step)*step;

    /* labels */
    cr->set_fig_font(18, 15, 100);
    for (double x=xmin; x<=xmax; x+=step){
      for (double y=ymin; y<=ymax; y+=step){
        stringstream sx, sy;
        sx << int(x/1000), sy << int(y/1000);
        dPoint p1(x,y); cnv1.bck(p1);
        cr->move_to(p1-dorg + dPoint(5, -5));
        cr->show_text(sy.str());
        cr->move_to(p1-dorg + dPoint(20, -25));
        cr->save();
        cr->rotate(-M_PI/2.0);
        cr->show_text(sx.str());
        cr->restore();
      }
    }

  }

  return GObj::FILL_PART;
}