static void
export_svg ()
{
cairo_surface_t *surface;
cairo_rectangle_t extents;
cairo_matrix_t mtx;
cairo_t *cr;
/* Create a surface and run export_layout_page() to figure out
* the picture extents and set up the cairo transformation
* matrix. The surface is created only in order to force
* eda_renderer_default_get_user_bounds() to behave quietly. */
surface = cairo_svg_surface_create (settings.outfile, 0, 0);
cr = cairo_create (surface);
g_object_set (renderer, "cairo-context", cr, NULL);
export_layout_page (NULL, &extents, &mtx);
cairo_destroy (cr);
/* Now create a new surface with the known extents. */
surface = cairo_svg_surface_create (settings.outfile,
extents.width,
extents.height);
cr = cairo_create (surface);
g_object_set (renderer, "cairo-context", cr, NULL);
cairo_set_matrix (cr, &mtx);
export_draw_page (NULL);
cairo_show_page (cr);
cairo_surface_finish (surface);
export_cairo_check_error (cairo_surface_status (surface));
}
void address_histogram::render_bars(cairo_t *cr, const plot::bounds_t &bounds)
{
if(top_addrs.size() < 1 || top_addrs.at(0).count == 0) {
return;
}
cairo_matrix_t original_matrix;
cairo_get_matrix(cr, &original_matrix);
cairo_translate(cr, bounds.x, bounds.y);
double offset_unit = bounds.width / top_addrs.size();
double bar_width = offset_unit / bar_space_factor;
double space_width = offset_unit - bar_width;
uint64_t greatest = top_addrs.at(0).count;
int index = 0;
for(vector<iptree::addr_elem>::const_iterator it = top_addrs.begin();
it != top_addrs.end(); it++) {
double bar_height = (((double) it->count) / ((double) greatest)) * bounds.height;
if(bar_height > 0) {
// bar
double bar_x = index * offset_unit + space_width;
double bar_y = bounds.height - bar_height;
cairo_set_source_rgb(cr, bar_color.r, bar_color.g, bar_color.b);
cairo_rectangle(cr, bar_x, bar_y, bar_width, bar_height);
cairo_fill(cr);
// bar label
std::string label = it->str();
// IP6 labels are half size since they're (potentially) much longer
if(it->is4()) {
cairo_set_font_size(cr, bar_label_font_size);
}
else {
cairo_set_font_size(cr, bar_label_font_size / 2.0);
}
cairo_text_extents_t label_extents;
cairo_text_extents(cr, label.c_str(), &label_extents);
cairo_move_to(cr, bar_x + bar_width / 2.0, bar_y);
cairo_matrix_t unrotated_matrix;
cairo_get_matrix(cr, &unrotated_matrix);
cairo_rotate(cr, -M_PI / 4.0);
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
cairo_show_text(cr, label.c_str());
cairo_set_matrix(cr, &unrotated_matrix);
}
index++;
}
cairo_set_matrix(cr, &original_matrix);
}
void PdfCache::render(cairo_t * cr, XojPopplerPage * popplerPage, double zoom) {
XOJ_CHECK_TYPE(PdfCache);
g_mutex_lock(this->renderMutex);
this->setZoom(zoom);
cairo_surface_t * img = lookup(popplerPage);
if (img == NULL) {
img = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, popplerPage->getWidth() * this->zoom, popplerPage->getHeight() * this->zoom);
cairo_t * cr2 = cairo_create(img);
cairo_scale(cr2, this->zoom, this->zoom);
popplerPage->render(cr2, false);
cairo_destroy(cr2);
cache(popplerPage, img);
}
cairo_matrix_t mOriginal;
cairo_matrix_t mScaled;
cairo_get_matrix(cr, &mOriginal);
cairo_get_matrix(cr, &mScaled);
mScaled.xx = 1;
mScaled.yy = 1;
mScaled.xy = 0;
mScaled.yx = 0;
cairo_set_matrix(cr, &mScaled);
cairo_set_source_surface(cr, img, 0, 0);
cairo_paint(cr);
cairo_set_matrix(cr, &mOriginal);
g_mutex_unlock(this->renderMutex);
}
void match(unsigned int position)
{
// cairo_set_line_cap(cairoOut, CAIRO_LINE_CAP_ROUND);
m_sensorReference.seek(position);
cairo_matrix_t m1;
cairo_get_matrix(cairoOut, &m1);
cairo_identity_matrix(cairoOut);
cairo_set_source_surface(cairoOut, cairo_get_target(cairoMap), 0., 0.);
cairo_paint(cairoOut);
cairo_set_matrix(cairoOut, &m1);
// cairo_set_line_width(cairoOut, 1./(2.*scaleFactor));
std::vector<InterestPoint *> pointsLocal(m_pointsReference[position].size());
const LaserReading* lreadReference = dynamic_cast<const LaserReading*>(m_sensorReference.current());
for(unsigned int j = 0; j < m_pointsReference[position].size(); j++){
InterestPoint * point = new InterestPoint(*m_pointsReference[position][j]);
point->setPosition(lreadReference->getLaserPose().ominus(point->getPosition()));
pointsLocal[j] = point;
}
for(unsigned int i = 0; i < m_pointsReference.size(); i++){
if(i == position) {
continue;
}
OrientedPoint2D transform;
std::vector< std::pair<InterestPoint*, InterestPoint* > > correspondences;
double result = m_ransac->matchSets(m_pointsReference[i], pointsLocal, transform, correspondences);
if(correspondences.size() >= corresp) {
cairo_matrix_t m;
cairo_get_matrix(cairoOut, &m);
cairo_translate(cairoOut, transform.x, transform.y);
cairo_rotate(cairoOut, transform.theta);
cairo_set_source_rgba(cairoOut, 1., 0., 0., 1. - result/(acceptanceSigma * acceptanceSigma * 5.99 * double(pointsLocal.size())));
cairo_move_to(cairoOut, 0., -0.3);
cairo_line_to(cairoOut, 0.6, 0.);
cairo_line_to(cairoOut, 0., 0.3);
cairo_close_path(cairoOut);
cairo_fill(cairoOut);
cairo_set_matrix(cairoOut, &m);
}
}
cairo_matrix_t m;
cairo_get_matrix(cairoOut, &m);
cairo_translate(cairoOut, lreadReference->getLaserPose().x, lreadReference->getLaserPose().y);
cairo_rotate(cairoOut, lreadReference->getLaserPose().theta);
cairo_set_source_rgba(cairoOut, 0., 0., 1., 1.);
cairo_move_to(cairoOut, 0., -0.3);
cairo_line_to(cairoOut, 0.6, 0.);
cairo_line_to(cairoOut, 0., 0.3);
cairo_close_path(cairoOut);
cairo_stroke(cairoOut);
cairo_set_matrix(cairoOut, &m);
// cairo_show_page(cairoOut);
}
CAMLprim value
ml_cairo_set_matrix (value v_cr, value v_matrix)
{
#ifndef ARCH_ALIGN_DOUBLE
cairo_set_matrix (cairo_t_val (v_cr), cairo_matrix_t_val (v_matrix));
#else
cairo_matrix_t mat;
ml_convert_cairo_matrix_in (v_matrix, &mat);
cairo_set_matrix (cairo_t_val (v_cr), &mat);
#endif
check_cairo_status (v_cr);
return Val_unit;
}
wxSVGRect wxSVGCanvasPathCairo::GetBBox(const wxSVGMatrix& matrix) {
if (&matrix) {
cairo_matrix_t m;
cairo_matrix_init(&m, matrix.GetA(), matrix.GetB(), matrix.GetC(), matrix.GetD(), matrix.GetE(), matrix.GetF());
cairo_set_matrix(m_cr, &m);
}
double x1, y1, x2, y2;
cairo_fill_extents(m_cr, &x1, &y1, &x2, &y2);
if (&matrix) {
cairo_matrix_t mat;
cairo_matrix_init(&mat, 1, 0, 0, 1, 0, 0);
cairo_set_matrix(m_cr, &mat);
}
return wxSVGRect(x1, y1, x2 - x1, y2 - y1);
}
static void
draw_stuff(cairo_t *cr, int width, int height)
{
cairo_matrix_t m;
cairo_get_matrix (cr, &m);
cairo_translate(cr, width / 2, height / 2);
cairo_scale(cr, width / 2, height / 2);
cairo_set_source_rgba(cr, 0, 0, 0.3, 1.0);
cairo_set_source_rgba(cr, 0, 0, 0, 1.0);
cairo_rectangle(cr, -1, -1, 2, 2);
cairo_fill(cr);
cairo_set_source_rgb(cr, 1, 0, 0);
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, 0, -1);
cairo_save(cr);
cairo_set_matrix(cr, &m);
cairo_set_line_width(cr, 2.0);
cairo_stroke(cr);
cairo_restore(cr);
cairo_set_source_rgb(cr, 0, 1, 0);
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, 1, 0);
cairo_save(cr);
cairo_set_matrix(cr, &m);
cairo_set_line_width(cr, 2.0);
cairo_stroke(cr);
cairo_restore(cr);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, 0, 1);
cairo_move_to(cr, 0, 0);
cairo_line_to(cr, -1, 0);
cairo_save(cr);
cairo_set_matrix(cr, &m);
cairo_set_line_width(cr, 2.0);
cairo_stroke(cr);
cairo_restore(cr);
cairo_destroy(cr);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_matrix_t m;
int xoffset = 50;
int yoffset = 50;
cairo_surface_t *shadow;
cairo_t *shadow_cr;
cairo_path_t *path;
cairo_set_source_rgb (cr, 1, 1, 1);
cairo_paint (cr);
cairo_translate (cr, 130, 130);
cairo_rotate (cr, .5);//2*M_PI*angle/360);
cairo_rectangle (cr, 0, 0, 50, 100);
cairo_get_matrix (cr, &m);
shadow = cairo_surface_create_similar (cairo_get_target (cr),
CAIRO_CONTENT_COLOR_ALPHA,
600 - xoffset,
600 - yoffset);
cairo_surface_set_device_offset (shadow, xoffset, yoffset);
shadow_cr = cairo_create (shadow);
cairo_surface_destroy (shadow);
cairo_set_source_rgb (shadow_cr, 0, 1, 0);
cairo_set_matrix (shadow_cr, &m);
path = cairo_copy_path (cr);
cairo_new_path (shadow_cr);
cairo_append_path (shadow_cr, path);
cairo_fill (shadow_cr);
cairo_path_destroy (path);
cairo_identity_matrix (cr);
cairo_translate (cr, 10, 50);
cairo_set_source_surface (cr, cairo_get_target (shadow_cr), 0, 0);
cairo_paint (cr);
cairo_set_matrix (cr, &m);
cairo_set_source_rgb (cr, 1, 0, 0);
cairo_fill (cr);
cairo_destroy (shadow_cr);
return CAIRO_TEST_SUCCESS;
}
void
ScaledFontBase::CopyGlyphsToBuilder(const GlyphBuffer &aBuffer, PathBuilder *aBuilder, const Matrix *aTransformHint)
{
#ifdef USE_CAIRO
PathBuilderCairo* builder = static_cast<PathBuilderCairo*>(aBuilder);
cairo_t *ctx = cairo_create(DrawTargetCairo::GetDummySurface());
if (aTransformHint) {
cairo_matrix_t mat;
GfxMatrixToCairoMatrix(*aTransformHint, mat);
cairo_set_matrix(ctx, &mat);
}
// Convert our GlyphBuffer into an array of Cairo glyphs.
std::vector<cairo_glyph_t> glyphs(aBuffer.mNumGlyphs);
for (uint32_t i = 0; i < aBuffer.mNumGlyphs; ++i) {
glyphs[i].index = aBuffer.mGlyphs[i].mIndex;
glyphs[i].x = aBuffer.mGlyphs[i].mPosition.x;
glyphs[i].y = aBuffer.mGlyphs[i].mPosition.y;
}
cairo_set_scaled_font(ctx, mScaledFont);
cairo_glyph_path(ctx, &glyphs[0], aBuffer.mNumGlyphs);
RefPtr<PathCairo> cairoPath = new PathCairo(ctx);
cairo_destroy(ctx);
cairoPath->AppendPathToBuilder(builder);
#endif
}
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_cairoSetMatrix
(JNIEnv *env, jobject obj, jdoubleArray java_matrix)
{
struct graphics2d *gr = NULL;
jdouble *native_matrix = NULL;
gr = (struct graphics2d *) NSA_GET_G2D_PTR (env, obj);
g_assert (gr != NULL);
native_matrix = (*env)->GetDoubleArrayElements (env, java_matrix, NULL);
g_assert (native_matrix != NULL);
g_assert ((*env)->GetArrayLength (env, java_matrix) == 6);
if (gr->debug) printf ("cairo_set_matrix [ %f, %f, %f, %f, %f, %f ]\n",
native_matrix[0], native_matrix[1],
native_matrix[2], native_matrix[3],
native_matrix[4], native_matrix[5]);
{
cairo_matrix_t * mat = cairo_matrix_create ();
cairo_matrix_set_affine (mat,
native_matrix[0], native_matrix[1],
native_matrix[2], native_matrix[3],
native_matrix[4], native_matrix[5]);
cairo_set_matrix (gr->cr, mat);
cairo_matrix_destroy (mat);
}
(*env)->ReleaseDoubleArrayElements (env, java_matrix, native_matrix, 0);
update_pattern_transform (gr);
}
/**
* Renders the SVG, performing any necessary transformations.
*/
void graphic_render (Graphic* self, cairo_t* context) {
cairo_matrix_t oldMatrix = {0};
cairo_t* _tmp0_ = NULL;
cairo_matrix_t _tmp1_ = {0};
cairo_t* _tmp2_ = NULL;
gint _tmp3_ = 0;
gint _tmp4_ = 0;
RsvgHandle* _tmp5_ = NULL;
cairo_t* _tmp6_ = NULL;
cairo_t* _tmp7_ = NULL;
cairo_matrix_t _tmp8_ = {0};
g_return_if_fail (self != NULL);
g_return_if_fail (context != NULL);
_tmp0_ = context;
cairo_get_matrix (_tmp0_, &_tmp1_);
oldMatrix = _tmp1_;
_tmp2_ = context;
_tmp3_ = self->priv->xCentre;
_tmp4_ = self->priv->yCentre;
cairo_translate (_tmp2_, (gdouble) (-_tmp3_), (gdouble) (-_tmp4_));
_tmp5_ = self->priv->svgHandle;
_tmp6_ = context;
rsvg_handle_render_cairo (_tmp5_, _tmp6_);
_tmp7_ = context;
_tmp8_ = oldMatrix;
cairo_set_matrix (_tmp7_, &_tmp8_);
}
void wtk_widget_render(wtk_widget_t *widget, cairo_t *context, int focused)
{
cllist_t *_w;
cairo_matrix_t m;
cairo_get_matrix(context, &m);
cairo_translate(context, widget->rect.x, widget->rect.y);
cairo_save(context);
//if (focused)
// printf("renderfocus\n");
if (widget->callbacks.paint)
widget->callbacks.paint(widget, context, focused);
else {
cairo_rectangle(context, 0, 0, widget->rect.w, widget->rect.h);
cairo_set_source_rgb(context, ((double)0xF6) / 255.0, ((double)0xF4) / 255.0, ((double)0xF2) / 255.0);
cairo_fill(context);
}
cairo_restore(context);
for (_w = widget->children.next; _w != &(widget->children); _w = _w->next)
wtk_widget_render((wtk_widget_t *) _w, context, widget->focused == (wtk_widget_t *) _w);
cairo_set_matrix(context, &m);
widget->flags &= ~WTK_WIDGET_FLAG_DIRTY;
}
bool
Image::InsideObject (cairo_t *cr, double x, double y)
{
if (!FrameworkElement::InsideObject (cr, x, y))
return false;
cairo_save (cr);
cairo_new_path (cr);
cairo_set_matrix (cr, &absolute_xform);
double nx = x;
double ny = y;
TransformPoint (&nx, &ny);
Render (cr, NULL, true);
bool inside = cairo_in_fill (cr, nx, ny);
cairo_restore (cr);
if (inside)
inside = InsideLayoutClip (x, y);
if (inside)
inside = InsideClip (cr, x, y);
return inside;
}
static void cairogen_ellipse(GVJ_t * job, pointf * A, int filled)
{
obj_state_t *obj = job->obj;
cairo_t *cr = (cairo_t *) job->context;
cairo_matrix_t matrix;
double rx, ry;
cairogen_set_penstyle(job, cr);
cairo_get_matrix(cr, &matrix);
rx = A[1].x - A[0].x;
ry = A[1].y - A[0].y;
#define RMIN 0.01
if (rx < RMIN) rx = RMIN;
if (ry < RMIN) ry = RMIN;
cairo_translate(cr, A[0].x, -A[0].y);
cairo_scale(cr, rx, ry);
cairo_move_to(cr, 1., 0.);
cairo_arc(cr, 0., 0., 1., 0., 2 * M_PI);
cairo_set_matrix(cr, &matrix);
if (filled == GRADIENT || filled == (RGRADIENT)) {
cairo_gradient_fill (cr, obj, filled, A, 2);
}
else if (filled) {
cairogen_set_color(cr, &(obj->fillcolor));
cairo_fill_preserve(cr);
}
cairogen_set_color(cr, &(obj->pencolor));
cairo_stroke(cr);
}
void
ge_cairo_transform_for_layout (cairo_t *cr,
PangoLayout *layout,
int x,
int y)
{
const PangoMatrix *matrix;
matrix = pango_context_get_matrix (pango_layout_get_context (layout));
if (matrix)
{
cairo_matrix_t cairo_matrix;
PangoRectangle rect;
cairo_matrix_init (&cairo_matrix,
matrix->xx, matrix->yx,
matrix->xy, matrix->yy,
matrix->x0, matrix->y0);
pango_layout_get_extents (layout, NULL, &rect);
pango_matrix_transform_rectangle (matrix, &rect);
pango_extents_to_pixels (&rect, NULL);
cairo_matrix.x0 += x - rect.x;
cairo_matrix.y0 += y - rect.y;
cairo_set_matrix (cr, &cairo_matrix);
}
else
cairo_translate (cr, x, y);
}
// Constructor.
Graphics2D::Graphics2D(const double design_x, const double design_y) {
// Adjust the scale to fit default image size.
scale = min(2048/design_x, 2048/design_y);
// Perform the linear scaling to suit with the placement layout.
img_x = design_x*scale;
img_y = design_y*scale;
// Cairo surface.
surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, img_x, img_y);
// Cairo context.
painter = cairo_create(surface);
cairo_set_line_width(painter, 10.0/scale);
cairo_set_source_rgb(painter, 1.0, 1.0, 1.0); // Default black background.
cairo_paint(painter); // Set the painter.
//cairo_set_line_width(painter, 5); // Default line width.
// Apply the affine transformation: flipping y and scalling x/y.
//
// scale, 0, 0 x
// [ ] * [ y ]
// 0, -scale, scale*design_y 1
//
cairo_matrix_init(&matrix, scale, 0, 0, -scale, 0, scale*design_y);
cairo_set_matrix(painter, &matrix);
}
static void
export_pdf (void)
{
cairo_surface_t *surface;
cairo_rectangle_t extents;
cairo_matrix_t mtx;
cairo_t *cr;
GList *iter;
/* Create a surface. To begin with, we don't know the size. */
surface = cairo_pdf_surface_create (settings.outfile, 1, 1);
cr = cairo_create (surface);
g_object_set (renderer, "cairo-context", cr, NULL);
for (iter = geda_list_get_glist (toplevel->pages);
iter != NULL;
iter = g_list_next (iter)) {
PAGE *page = (PAGE *) iter->data;
export_layout_page (page, &extents, &mtx);
cairo_pdf_surface_set_size (surface, extents.width, extents.height);
cairo_set_matrix (cr, &mtx);
export_draw_page (page);
cairo_show_page (cr);
}
cairo_surface_finish (surface);
export_cairo_check_error (cairo_surface_status (surface));
}
void wxGISDisplay::SetDrawCache(size_t nCacheId, bool bNoDerty)
{
wxCriticalSectionLocker locker(m_CritSect);
if (bNoDerty || nCacheId == 0)
m_nCurrentLayer = nCacheId;
else
{
//merge previous cache
if (m_nCurrentLayer > nCacheId)
{
m_nCurrentLayer = nCacheId - 1;
}
//TODO: clip by frame size cairo_clip()?
//TODO: rewrite to parallel cache drawing
for (int i = m_nCurrentLayer; i < nCacheId; ++i)
{
cairo_save(m_saLayerCaches[i + 1].pCairoContext);
cairo_matrix_t mat = {1, 0, 0, 1, 0, 0};
cairo_set_matrix(m_saLayerCaches[i + 1].pCairoContext, &mat);
cairo_set_source_surface(m_saLayerCaches[i + 1].pCairoContext, m_saLayerCaches[i].pCairoSurface, 0, 0);
cairo_set_operator(m_saLayerCaches[i + 1].pCairoContext, CAIRO_OPERATOR_SOURCE);
cairo_paint(m_saLayerCaches[i + 1].pCairoContext);
cairo_restore(m_saLayerCaches[i + 1].pCairoContext);
}
m_nCurrentLayer = nCacheId;
}
}
void
terranova_mirror_rotate (cairo_t *cr, double radius, double x, double y,
boolean mirror_horizontally, boolean mirror_vertically)
{
cairo_matrix_t matrix_rotate;
cairo_matrix_t matrix_mirror;
cairo_matrix_t matrix_result;
double r_cos = cos(radius);
double r_sin = sin(radius);
cairo_matrix_init (&matrix_rotate, r_cos,
r_sin,
r_sin,
r_cos,
x, y);
cairo_matrix_init (&matrix_mirror, mirror_horizontally ? -1 : 1,
0,
0,
mirror_vertically ? -1 : 1,
0, 0);
cairo_matrix_multiply (&matrix_result, &matrix_mirror, &matrix_rotate);
cairo_set_matrix (cr, &matrix_result);
}
void
GeometryGroup::Draw (cairo_t *cr)
{
Transform *transform = GetTransform ();
cairo_matrix_t saved;
cairo_get_matrix (cr, &saved);
if (transform) {
cairo_matrix_t matrix;
transform->GetTransform (&matrix);
cairo_transform (cr, &matrix);
}
GeometryCollection *children = GetChildren ();
Geometry *geometry;
// GeometryGroup is used for Clip (as a Geometry) so Fill (normally setting the fill rule) is never called
cairo_set_fill_rule (cr, convert_fill_rule (GetFillRule ()));
int children_count = children->GetCount ();
for (int i = 0; i < children_count; i++) {
geometry = children->GetValueAt (i)->AsGeometry ();
geometry->Draw (cr);
}
cairo_set_matrix (cr, &saved);
}
static VALUE
cr_set_matrix (VALUE self, VALUE matrix)
{
cairo_set_matrix (_SELF, RVAL2CRMATRIX (matrix));
cr_check_status (_SELF);
return self;
}
/*==================================================================================
psbspl - subroutine to generate open bsplines
We receive only the vertices from perplex, so we must figure out good control
points to use for the spline.
==================================================================================*/
void psbspl_ (double *x, double *y, int *npts, double *rline, double *width, int *ifill) {
int i, N;
double ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y;
N = *npts;
DEBUGPRINT(("In psbspl. With %i points, rline=%f, wdith=%f, fill=%i.\n", N, *rline, *width, *ifill));
completeRelativeOperation();
if (dmh_inRotatedTransform) {
cairo_set_matrix(dmh_cr, &dmh_unrotatedMatrix); /* remove rotation */
dmh_inRotatedTransform = 0;
DEBUGPRINT(("Removing rotation.\n"));
}
if (N >= 4) {
cairo_move_to(dmh_cr, deviceX(x[0]), deviceY(y[0]));
getControlPoints(deviceX(x[0]), deviceY(y[0]), deviceX(x[0]), deviceY(y[0]),
deviceX(x[1]), deviceY(y[1]), deviceX(x[2]), deviceY(y[2]),
&ctrl1_x, &ctrl1_y, &ctrl2_x, &ctrl2_y);
cairo_curve_to(dmh_cr, ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, deviceX(x[1]), deviceY(y[1]));
// cairo_line_to(dmh_cr, deviceX(x[1]), deviceY(y[1]));
for (i=1; i <= N-3; i++) {
getControlPoints(deviceX(x[i-1]), deviceY(y[i-1]), deviceX(x[i]), deviceY(y[i]),
deviceX(x[i+1]), deviceY(y[i+1]), deviceX(x[i+2]), deviceY(y[i+2]),
&ctrl1_x, &ctrl1_y, &ctrl2_x, &ctrl2_y);
cairo_curve_to(dmh_cr, ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, deviceX(x[i+1]), deviceY(y[i+1]));
}
/* We've now drawn all the way to N-2. We need to draw through N-1.
We can get one more control point by working backwards from the end: */
getControlPoints(deviceX(x[N-3]), deviceY(y[N-3]), deviceX(x[N-2]), deviceY(y[N-2]),
deviceX(x[N-1]), deviceY(y[N-1]), deviceX(x[N-1]), deviceY(y[N-1]),
&ctrl1_x, &ctrl1_y, &ctrl2_x, &ctrl2_y);
cairo_curve_to(dmh_cr, ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, deviceX(x[N-1]), deviceY(y[N-1]));
// cairo_line_to(dmh_cr, deviceX(x[N-1]), deviceY(y[N-1]));
} else if (N == 3) {
/* for three points, we'll pretend for the purposes of control point calculation that
it's a closed loop */
cairo_move_to(dmh_cr, deviceX(x[0]), deviceY(y[0]));
getControlPoints(deviceX(x[2]), deviceY(y[2]), deviceX(x[0]), deviceY(y[0]),
deviceX(x[1]), deviceY(y[1]), deviceX(x[2]), deviceY(y[2]),
&ctrl1_x, &ctrl1_y, &ctrl2_x, &ctrl2_y);
cairo_curve_to(dmh_cr, ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, deviceX(x[1]), deviceY(y[1]));
getControlPoints(deviceX(x[0]), deviceY(y[0]), deviceX(x[1]), deviceY(y[1]),
deviceX(x[2]), deviceY(y[2]), deviceX(x[0]), deviceY(y[0]),
&ctrl1_x, &ctrl1_y, &ctrl2_x, &ctrl2_y);
cairo_curve_to(dmh_cr, ctrl1_x, ctrl1_y, ctrl2_x, ctrl2_y, deviceX(x[2]), deviceY(y[2]));
} else if (N == 2) {
/* for two points, it's a line segment. Duh. */
cairo_move_to(dmh_cr, deviceX(x[0]), deviceY(y[0]));
cairo_line_to(dmh_cr, deviceX(x[1]), deviceY(y[1]));
}
setLineProperties((int) *rline, *width);
cairo_set_source_rgb (dmh_cr, 0, 0, 0); /* black */
cairo_stroke_preserve(dmh_cr);
setFillType (*ifill);
cairo_fill(dmh_cr);
}
void
gfxContext::NudgeCurrentMatrixToIntegers()
{
cairo_matrix_t mat;
cairo_get_matrix(mCairo, &mat);
gfxMatrix(*reinterpret_cast<gfxMatrix*>(&mat)).NudgeToIntegers();
cairo_set_matrix(mCairo, &mat);
}
void VectorGraphics::pop_matrix() {
if(matrix_stack_.empty()) {
cairo_identity_matrix(cr());
} else {
cairo_set_matrix(cr(), &matrix_stack_.front());
matrix_stack_.pop_front();
}
}
void CairoDevice::SetOrigin( float x, float y )
{
cairo_matrix_t matrix;
cairo_get_matrix (fNativeDevice, &matrix);
matrix.x0 = x;
matrix.y0 = y;
cairo_set_matrix (fNativeDevice, &matrix);
}
static int
cr_set_matrix (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
cairo_matrix_t mat;
from_lua_matrix(L, &mat, 2);
cairo_set_matrix(*obj, &mat);
return 0;
}
void wxGISDisplay::InitTransformMatrix(void)
{
m_dFrameCenterX = m_oDeviceFrameRect.GetWidth() / 2;
m_dFrameCenterY = m_oDeviceFrameRect.GetHeight() / 2;
double dWorldCenterX = (m_CurrentBounds.MaxX - m_CurrentBounds.MinX) / 2;
double dWorldCenterY = (m_CurrentBounds.MaxY - m_CurrentBounds.MinY) / 2;
//origin (UL corner)
m_dOrigin_X = m_dCacheCenterX - m_dFrameCenterX;
m_dOrigin_Y = m_dCacheCenterY - m_dFrameCenterY;
//get scale
double dScaleX = fabs(m_dFrameCenterX / dWorldCenterX);
double dScaleY = fabs(m_dFrameCenterY / dWorldCenterY);
m_dScale = wxMin(dScaleX, dScaleY);
double dWorldDeltaX = dWorldCenterX + m_CurrentBounds.MinX;
double dWorldDeltaY = dWorldCenterY + m_CurrentBounds.MinY;
double dWorldDeltaXSt = m_dScale * dWorldDeltaX;// + m_dAngleRad * dWorldDeltaY;
double dWorldDeltaYSt = m_dScale * dWorldDeltaY;//m_dAngleRad * dWorldDeltaX +
//double dCenterX = m_dCacheCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;//
//double dCenterY = m_dCacheCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;//
m_dFrameXShift = m_dFrameCenterX - dWorldDeltaXSt;//(dWorldCenterX + m_CurrentBounds.MinX) * dScale;//
m_dFrameYShift = m_dFrameCenterY + dWorldDeltaYSt;//(dWorldCenterY + m_CurrentBounds.MinY) * dScale;//
// cairo_matrix_init (m_pMatrix, 1, 0, 0, 1, m_dCacheCenterX, m_dCacheCenterY);
//cairo_matrix_init (m_pMatrix, dScale, 0.0, 0.0, -dScale, dCenterX, dCenterY);
cairo_matrix_init_translate (m_pMatrix, m_dCacheCenterX, m_dCacheCenterY);
//rotate
//cairo_matrix_rotate(m_pMatrix, 45.0 * M_PI / 180.0);
if(!IsDoubleEquil(m_dAngleRad, 0.0))
//{
//cairo_matrix_translate(m_pMatrix, dWorldDeltaXSt, dWorldDeltaYSt);
cairo_matrix_rotate(m_pMatrix, m_dAngleRad);
//cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt);
//}
//else
cairo_matrix_translate(m_pMatrix, -dWorldDeltaXSt, dWorldDeltaYSt);
cairo_matrix_scale(m_pMatrix, m_dScale, -m_dScale);
//init matrix for Wld2DC & DC2Wld
cairo_matrix_init_translate (m_pDisplayMatrix, m_dFrameCenterX, m_dFrameCenterY);
if(!IsDoubleEquil(m_dAngleRad, 0.0))
cairo_matrix_rotate(m_pDisplayMatrix, m_dAngleRad);
cairo_matrix_translate(m_pDisplayMatrix, -dWorldDeltaXSt, dWorldDeltaYSt);
cairo_matrix_scale(m_pDisplayMatrix, m_dScale, -m_dScale);
//init matrix for TransformRect
cairo_matrix_init_translate (m_pDisplayMatrixNoRotate, m_dFrameCenterX, m_dFrameCenterY);
cairo_matrix_translate(m_pDisplayMatrixNoRotate, -dWorldDeltaXSt, dWorldDeltaYSt);
cairo_matrix_scale(m_pDisplayMatrixNoRotate, m_dScale, -m_dScale);
//set matrix to all caches
for(size_t i = 0; i < m_saLayerCaches.size(); ++i)
cairo_set_matrix (m_saLayerCaches[i].pCairoContext, m_pMatrix);
}
static void
redraw_handler(struct widget *widget, void *data)
{
struct image *image = data;
struct rectangle allocation;
cairo_t *cr;
cairo_surface_t *surface;
double width, height, doc_aspect, window_aspect, scale;
cairo_matrix_t matrix;
cairo_matrix_t translate;
surface = window_get_surface(image->window);
cr = cairo_create(surface);
widget_get_allocation(image->widget, &allocation);
cairo_rectangle(cr, allocation.x, allocation.y,
allocation.width, allocation.height);
cairo_clip(cr);
cairo_push_group(cr);
cairo_translate(cr, allocation.x, allocation.y);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(cr, 0, 0, 0, 1);
cairo_paint(cr);
if (!image->initialized) {
image->initialized = true;
width = cairo_image_surface_get_width(image->image);
height = cairo_image_surface_get_height(image->image);
doc_aspect = width / height;
window_aspect = (double) allocation.width / allocation.height;
if (doc_aspect < window_aspect)
scale = allocation.height / height;
else
scale = allocation.width / width;
image->width = width;
image->height = height;
cairo_matrix_init_scale(&image->matrix, scale, scale);
clamp_view(image);
}
matrix = image->matrix;
cairo_matrix_init_translate(&translate, allocation.x, allocation.y);
cairo_matrix_multiply(&matrix, &matrix, &translate);
cairo_set_matrix(cr, &matrix);
cairo_set_source_surface(cr, image->image, 0, 0);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_paint(cr);
cairo_pop_group_to_source(cr);
cairo_paint(cr);
cairo_destroy(cr);
cairo_surface_destroy(surface);
}
void ofCairoRenderer::popMatrix(){
if(!surface || !cr) return;
cairo_set_matrix(cr,&matrixStack.top());
matrixStack.pop();
if(!b3D) return;
modelView = modelViewStack.top();
modelViewStack.pop();
}
static bool read_tiles(cairo_t *cr,
struct _openslide_level *level,
struct _openslide_grid *grid,
struct region *region,
read_tiles_callback_fn callback,
void *arg,
GError **err) {
//g_debug("offset: %g %g, advance: %g %g", region->offset_x, region->offset_y, grid->tile_advance_x, grid->tile_advance_y);
if (fabs(region->offset_x) >= grid->tile_advance_x) {
g_set_error(err, OPENSLIDE_ERROR, OPENSLIDE_ERROR_FAILED,
"internal error: fabs(offset_x) >= tile_advance_x");
return false;
}
if (fabs(region->offset_y) >= grid->tile_advance_y) {
g_set_error(err, OPENSLIDE_ERROR, OPENSLIDE_ERROR_FAILED,
"internal error: fabs(offset_y) >= tile_advance_y");
return false;
}
// cairo_set_source_rgb(cr, 0, 1, 0);
// cairo_paint(cr);
//g_debug("offset: %d %d", region->offset_x, region->offset_y);
//g_debug("start: %"PRId64" %"PRId64, region->start_tile_x, region->start_tile_y);
//g_debug("end: %"PRId64" %"PRId64, region->end_tile_x, region->end_tile_y);
cairo_matrix_t matrix;
cairo_get_matrix(cr, &matrix);
int64_t tile_y = region->end_tile_y - 1;
while (tile_y >= region->start_tile_y) {
double translate_y = ((tile_y - region->start_tile_y) *
grid->tile_advance_y) - region->offset_y;
int64_t tile_x = region->end_tile_x - 1;
while (tile_x >= region->start_tile_x) {
double translate_x = ((tile_x - region->start_tile_x) *
grid->tile_advance_x) - region->offset_x;
// g_debug("read_tiles %"PRId64" %"PRId64, tile_x, tile_y);
cairo_translate(cr, translate_x, translate_y);
bool success = callback(grid, region, cr,
level, tile_x, tile_y,
arg, err);
cairo_set_matrix(cr, &matrix);
if (!success) {
return false;
}
tile_x--;
}
tile_y--;
}
return true;
}
