Bitmap/Bézier curves/Quadratic: Difference between revisions

Using the data storage type defined [[Basic_bitmap_storage|on this page]] for raster images, and the <tt>draw_line</tt> function defined in [[Bresenham's_line_algorithm|this one]], draw a ''quadratic bezier curve''

([[wp:Bezier_curves#Quadratic_B.C3.A9zier_curves|definition on Wikipedia]]).

=={{header|Action!}}==

{{libheader|Action! Bitmap tools}}

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

INCLUDE "H6:REALMATH.ACT"

 

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/B%C3%A9zier_curves_quadratic.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

( Picture : in out Image;

P1, P2, P3 : Point;

end Quadratic_Bezier;</syntaxhighlight>

The following test

begin

Fill (X, White);

 

</pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

[[Image:bezierquad_bbc.gif|right]]

Height% = 200

LINE x%*2,y%*2,x%*2,y%*2

ENDPROC</syntaxhighlight>

=={{header|C}}==

 

Interface (to be added to all other to make the final <tt>imglib.h</tt>):

 

image img,

unsigned int x1, unsigned int y1,

Implementation:

 

 

/* number of segments for the curve */

#undef plot

#undef line</syntaxhighlight>

=={{header|Commodore Basic}}==

10 rem bezier curve algorihm

20 rem translated from purebasic

</syntaxhighlight>

[https://www.worldofchris.com/assets/c64-bezier-curve.png Screenshot of Bézier curve on C64]

=={{header|D}}==

This solution uses two modules, from the Grayscale image and the Bresenham's line algorithm Tasks.

 

struct Pt { int x, y; } // Signed.

....................

....................</pre>

=={{header|Factor}}==

Some code is shared with the cubic bezier task, but I put it here again to make it simple (hoping the two version don't diverge)

Same remark as with cubic bezier, the points could go into a sequence to simplify stack shuffling

rosettacode.raster.storage sequences ;

IN: rosettacode.raster.line

{R,G,B} swap image draw-lines ;

</syntaxhighlight>

=={{header|FBSL}}==

Windows' graphics origin is located at the bottom-left corner of device bitmap.

 

'''Translation of BBC BASIC using pure FBSL's built-in graphics functions:'''

#DEFINE WM_CLOSE 16

 

END SUB</syntaxhighlight>

'''Output:''' [[File:FBSLBezierQuad.PNG]]

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

(This subroutine must be inside the <code>RCImagePrimitive</code> module, see [[Bresenham's line algorithm#Fortran|here]])

 

type(rgbimage), intent(inout) :: img

type(point), intent(in) :: p1, p2, p3

 

end subroutine quad_bezier</syntaxhighlight>

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

' compile with: fbc -s console

 

Sleep

End</syntaxhighlight>

=={{header|Go}}==

{{trans|C}}

 

const b2Seg = 20

Demonstration program:

[[File:GoBez2.png|thumb|right]]

 

import (

}

}</syntaxhighlight>

=={{header|Haskell}}==

FlexibleInstances, TypeSynonymInstances,

ViewPatterns #-}

f (curvePoint -> p1) (curvePoint -> p2) =

line i (toPixel p1) (toPixel p2) c</syntaxhighlight>

=={{header|J}}==

See [[Cubic bezier curves#J|Cubic bezier curves]] for a generalized solution.

=={{header|Julia}}==

See [[Cubic bezier curves#Julia]] for a generalized solution.

=={{header|Kotlin}}==

This incorporates code from other relevant tasks in order to provide a runnable example.

 

import java.awt.Color

=={{header|Lua}}==

Starting with the code from [[Bitmap/Bresenham's line algorithm#Lua|Bitmap/Bresenham's line algorithm]], then extending:

nseg = nseg or 10

local prevx, prevy, currx, curry

...........................XXXXXX............................

.............................................................</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Graphics[{BSplineCurve[pts], Green, Line[pts], Red, Point[pts]}]</syntaxhighlight>

Second solution using built-in function BezierCurve.

Graphics[{BezierCurve[pts], Green, Line[pts], Red, Point[pts]}]</syntaxhighlight>

[[File:MmaQuadraticBezier.png]]

=={{header|MATLAB}}==

Note: Store this function in a file named "bezierQuad.mat" in the @Bitmap folder for the Bitmap class defined [[Bitmap#MATLAB|here]].

function bezierQuad(obj,pixel_0,pixel_1,pixel_2,color,varargin)

 

Sample usage:

This will generate the image example for the Go solution.

>> img = Bitmap(400,300);

>> img.fill([223 255 239]);

>> disp(img)

</syntaxhighlight>

=={{header|Nim}}==

{{trans|Ada}}

We use module “bitmap” for bitmap management and module “bresenham” to draw segments.

import bresenham

import lenientops

................

................</pre>

=={{header|OCaml}}==

 

~p1:(_x1, _y1)

~p2:(_x2, _y2)

by_pair pts (fun p0 p1 -> line ~p0 ~p1);

;;</syntaxhighlight>

=={{header|Phix}}==

Output similar to [[Bitmap/Bézier_curves/Quadratic#Mathematica|Mathematica]]<br>

Requires new_image() from [[Bitmap#Phix|Bitmap]], bresLine() from [[Bitmap/Bresenham's_line_algorithm#Phix|Bresenham's_line_algorithm]], and write_ppm() from [[Bitmap/Write_a_PPM_file#Phix|Write_a_PPM_file]]. <br>

Results may be verified with demo\rosetta\viewppm.exw

include ppm.e -- black, green, red, white, new_image(), write_ppm(), bresLine() -- (covers above requirements)

 

img[200][1] = red

write_ppm("BezierQ.ppm",img)</syntaxhighlight>

=={{header|PicoLisp}}==

This uses the 'brez' line drawing function from

[[Bitmap/Bresenham's line algorithm#PicoLisp]].

 

(de quadBezier (Img N X1 Y1 X2 Y2 X3 Y3)

(inc 'Y DY) ) ) ) )</syntaxhighlight>

Test:

(quadBezier Img 12 20 100 300 -80 260 180)

(out "img.pbm" # Write to bitmap file

 

(call 'display "img.pbm")</syntaxhighlight>

=={{header|PureBasic}}==

Protected i

Protected.f T, t1, a, b, c, d

Until event = #PB_Event_CloseWindow

</syntaxhighlight>

=={{header|Python}}==

See [[Cubic bezier curves#Python]] for a generalized solution.

=={{header|R}}==

See [[Cubic bezier curves#R]] for a generalized solution.

=={{header|Racket}}==

#lang racket

(require racket/draw)

bm

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Uses pieces from [[Bitmap#Raku| Bitmap]], and [[Bitmap/Bresenham's_line_algorithm#Raku| Bresenham's line algorithm]] tasks. They are included here to make a complete, runnable program.

 

class Bitmap {

has UInt ($.width, $.height);

 

See [https://github.com/thundergnat/rc/blob/master/img/Bezier-quadratic-perl6.png example image here], (converted to a .png as .ppm format is not widely supported).

=={{header|Ruby}}==

See [[Cubic bezier curves#Ruby]] for a generalized solution.

=={{header|Tcl}}==

See [[Cubic bezier curves#Tcl]] for a generalized solution.

=={{header|TI-89 BASIC}}==

 

{{TI-image-task}}

 

Local i,t,u,prev,pt

0 → pt

EndFor

EndPrgm</syntaxhighlight>

=={{header|Vedit macro language}}==

This implementation uses de Casteljau's algorithm to recursively split the Bezier curve into two smaller segments until the segment is short enough to be approximated with a straight line.

Constant recursion depth is used here. Recursion depth of 5 seems to give accurate enough result in most situations. In real world implementations, some adaptive method is often used to decide when to stop recursion.

 

// #20, #30 = Start point

// #21, #31 = Control point 1

}

return</syntaxhighlight>

=={{header|Wren}}==

{{libheader|DOME}}

Requires version 1.3.0 of DOME or later.

import "dome" for Window

 

static draw(alpha) {}

}</syntaxhighlight>

=={{header|XPL0}}==

[[File:QuadXPL0.png|right]]

 

proc Bezier(P0, P1, P2); \Draw quadratic Bezier curve

SetVid(3); \restore normal text display

]</syntaxhighlight>

=={{header|zkl}}==

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

 

Add this to the PPM class:

numPts.pump(Void,'wrap(t){ // B(t)

t=t.toFloat()/numPts; t1:=(1.0 - t);

}</syntaxhighlight>

Doesn't use line segments, they don't seem like an improvement.

bitmap.qBezier(10,100, 250,270, 150,20, 0);

bitmap.write(File("foo.ppm","wb"));</syntaxhighlight>

{{out}}

Same as the BBC BASIC image:[[Image:bezierquad_bbc.gif]]

{{omit from|AWK}}

{{omit from|GUISS}}