bool LineSegment::containPointOpen(Point pt)// judge whether the point is no the line { double zero = a * pt.x + b * pt.y + c; double tmp = DOUBLE_EQUAL(zero, 0); return (DOUBLE_EQUAL(zero, 0)); }
/** * image_view_set_zoom: * @view: An image view. * @zoomx: Horizontal zoom factor. * @zoomy: Vertical zoom factor. * @have_anchor: Whether the anchor point specified by (@anchorx, @anchory) * should be used. * @anchorx: Horizontal anchor point in pixels. * @anchory: Vertical anchor point in pixels. * * Sets the zoom factor for an image view. The anchor point can be used to * specify the point that stays fixed when the image is zoomed. If @have_anchor * is %TRUE, then (@anchorx, @anchory) specify the point relative to the image * view widget's allocation that will stay fixed when zooming. If @have_anchor * is %FALSE, then the center point of the image view will be used. **/ void image_view_set_zoom (ImageView *view, double zoomx, double zoomy, gboolean have_anchor, int anchorx, int anchory) { ImageViewPrivate *priv; g_return_if_fail (view != NULL); g_return_if_fail (IS_IMAGE_VIEW (view)); g_return_if_fail (zoomx > 0.0); g_return_if_fail (zoomy > 0.0); priv = view->priv; if (zoomx > MAX_ZOOM_FACTOR) zoomx = MAX_ZOOM_FACTOR; else if (zoomx < MIN_ZOOM_FACTOR) zoomx = MIN_ZOOM_FACTOR; if (zoomy > MAX_ZOOM_FACTOR) zoomy = MAX_ZOOM_FACTOR; else if (zoomy < MIN_ZOOM_FACTOR) zoomy = MIN_ZOOM_FACTOR; if (DOUBLE_EQUAL (priv->zoomx, zoomx) && DOUBLE_EQUAL (priv->zoomy, zoomy)) goto out; if (!priv->need_zoom_change) { priv->old_zoomx = priv->zoomx; priv->old_zoomy = priv->zoomy; priv->need_zoom_change = TRUE; } priv->zoomx = zoomx; priv->zoomy = zoomy; g_signal_emit (view, image_view_signals [ZOOM_CHANGED], 0); if (have_anchor) { anchorx = CLAMP (anchorx, 0, GTK_WIDGET (view)->allocation.width); anchory = CLAMP (anchory, 0, GTK_WIDGET (view)->allocation.height); set_zoom_anchor (view, anchorx, anchory); } else set_default_zoom_anchor (view); out: gtk_widget_queue_resize (GTK_WIDGET (view)); }
bool LineSegment::containPointClose(Point pt) { double minx = mymin(start.x, end.x); double maxx = mymax(start.x, end.x); double miny = mymin(start.y, end.y); double maxy = mymax(start.y, end.y); if (containPointOpen(pt) && (pt.x > minx || DOUBLE_EQUAL(pt.x, minx)) && (pt.x < maxx || DOUBLE_EQUAL(pt.x, maxx)) && (pt.y > miny || DOUBLE_EQUAL(pt.y, miny)) && (pt.y < maxy || DOUBLE_EQUAL(pt.y, maxy))) return true; else return false; }
/** *add two poly *node: it modifies rhs, (rhs will own no items) *@return: added poly result is stored in lhs * you need to set lhs to the new value */ void poly_add_inp(Poly** lhs, Poly* rhs) { Poly odd; Poly *p1, *q1, *p2; if (NULL == lhs) return; if (*lhs == rhs) return poly_mul_cons_inp(lhs, 2); odd.next = *lhs; p1 = odd.next, q1 = &odd, p2 = rhs; for (; NULL != p2 && NULL != p1;) { if (p1->index == p2->index) { p1->coeff += p2->coeff; if (DOUBLE_EQUAL(p1->coeff, 0)) { destroy_poly_head(&p1); //destory node p1 and move forward q1->next = p1; } destroy_poly_head(&p2); //destory node p2 and move forward } else if (p1->index < p2->index) { Poly* tmp_next = p2->next; p2->next = p1; q1->next = p2; q1 = q1->next; p2 = tmp_next; } else { q1 = p1; p1 = p1->next; } } if (NULL == p1) q1->next = p2; *lhs = odd.next; }
bool LineSegment::containPointExclusiveEnds(Point pt) { double minx = mymin(start.x, end.x); double maxx = mymax(start.x, end.x); double miny = mymin(start.y, end.y); double maxy = mymax(start.y, end.y); if (containPointOpen(pt) && (pt.x > minx || DOUBLE_EQUAL(pt.x, minx)) && (pt.x < maxx || DOUBLE_EQUAL(pt.x, maxx)) && (pt.y > miny || DOUBLE_EQUAL(pt.y, miny)) && (pt.y < maxy || DOUBLE_EQUAL(pt.y, maxy)) && pt.approxInequal(start) && pt.approxInequal(end)) return true; else return false; }
/** *negative index is not allowed *@return: stored quotient in plhs */ void poly_div_inp(Poly** plhs, const Poly* rhs) { Poly* lhs = *plhs; Poly odd = {.next = lhs}; Poly* res = NULL; if (NULL == lhs || NULL == rhs) return; if (*plhs == rhs) { //lhs and rhs are the same poly destroy_poly(plhs); *plhs = create_poly(1, 0); return; } for (; NULL != lhs && lhs->index >= rhs->index;) { Poly *p1, *q1; const Poly* p2; Poly* item = create_poly(lhs->coeff / rhs->coeff, lhs->index - rhs->index); poly_add_inp(&res, poly_copy(item)); //printf("res: \n"); //print_poly(res); for (p1 = lhs, q1 = &odd, p2 = rhs; NULL != p1 && NULL != p2;) { //print_poly(p2); if (p1->index - p2->index == item->index) { p1->coeff -= p2->coeff * item->coeff; //coeff may be zero if (DOUBLE_EQUAL(p1->coeff, 0)) { destroy_poly_head(&p1); //move forward q1->next = p1; } p2 = p2->next; } else if (p1->index - p2->index > item->index) { q1 = p1; p1 = p1->next; } else p2 = p2->next; } lhs = odd.next; //printf("lhs: \n"); //print_poly(lhs); } *plhs = odd.next; destroy_poly(plhs); *plhs = res; }
static gboolean unity_zoom (ImageViewPrivate *priv) { return (DOUBLE_EQUAL (priv->zoomx, 1.0) && DOUBLE_EQUAL (priv->zoomy, 1.0)); }