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

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

INCLUDE "H6:REALMATH.ACT"

 

DO UNTIL CH#$FF OD

CH=$FF

{{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;

Line (Picture, Points (I), Points (I + 1), Color);

end loop;

The following test

begin

Fill (X, White);

Quadratic_Bezier (X, (8, 2), (13, 8), (2, 15), Black);

should produce;

<pre>

{{works with|BBC BASIC for Windows}}

[[Image:bezierquad_bbc.gif|right]]

Height% = 200

GCOL 1

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

 

=={{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,

color_component r,

color_component g,

 

Implementation:

 

 

/* number of segments for the curve */

}

#undef plot

 

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

10 rem bezier curve algorihm

20 rem translated from purebasic

3160 next i

3170 return

[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.

im.quadraticBezier(Pt(1,10), Pt(25,27), Pt(15,2), Gray.black);

im.textualShow();

{{out}}

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

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

points-to-lines

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

 

=={{header|FBSL}}==

 

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

#DEFINE WM_CLOSE 16

 

WEND

END SUB

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

 

(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 do

 

 

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

 

=={{header|Go}}==

{{trans|C}}

 

const b2Seg = 20

func (b *Bitmap) Bézier2Rgb(x1, y1, x2, y2, x3, y3 int, c Rgb) {

b.Bézier2(x1, y1, x2, y2, x3, y3, c.Pixel())

Demonstration program:

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

 

import (

fmt.Println(err)

}

 

=={{header|Haskell}}==

FlexibleInstances, TypeSynonymInstances,

ViewPatterns #-}

pt n p = pmap (*n) p

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

 

=={{header|J}}==

=={{header|Kotlin}}==

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

 

import java.awt.Color

ImageIO.write(image, "jpg", qbFile)

}

=={{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

bitmap:clear()

bitmap:quadraticbezier( 1,1, 30,37, 59,1 )

{{out}}

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

 

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

Second solution using built-in function BezierCurve.

[[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)

 

end

 

Sample usage:

This will generate the image example for the Go solution.

>> img = Bitmap(400,300);

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

>> img.bezierQuad([20 150],[500 -100],[300 280],[63 143 239],21);

>> disp(img)

 

=={{header|Nim}}==

{{trans|Ada}}

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

import bresenham

import lenientops

img.fill(White)

img.drawQuadraticBezier((1, 7), (7, 12), (14, 1), Black)

 

{{out}}

=={{header|OCaml}}==

 

~p1:(_x1, _y1)

~p2:(_x2, _y2)

in

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

 

=={{header|Phix}}==

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[100][200] = red

img[200][1] = red

 

=={{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)

(setq DY (- (+ (*/ A Y1 1.0) (*/ B Y2 1.0) (*/ C Y3 1.0)) Y)) )

(inc 'X DX)

Test:

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

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

(mapc prinl Img) ) )

 

 

=={{header|PureBasic}}==

Protected i

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

event = WaitWindowEvent()

Until event = #PB_Event_CloseWindow

 

=={{header|Python}}==

 

=={{header|Racket}}==

#lang racket

(require racket/draw)

(draw-lines dc (bezier-points '(16 1) '(1 4) '(3 16)))

bm

 

=={{header|Raku}}==

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);

@points.map: { $b.dot( $_, color(255,0,0), 3 )}

 

 

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).

{{TI-image-task}}

 

Local i,t,u,prev,pt

0 → pt

EndIf

EndFor

 

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

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

Call("DRAW_LINE")

}

 

=={{header|Wren}}==

{{libheader|DOME}}

Requires version 1.3.0 of DOME or later.

import "dome" for Window

 

 

static draw(alpha) {}

 

=={{header|XPL0}}==

[[File:QuadXPL0.png|right]]

 

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

if ChIn(1) then []; \wait for keystroke

SetVid(3); \restore normal text display

 

=={{header|zkl}}==

 

Add this to the PPM class:

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

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

__sSet(rgb,x,y);

});

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

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

{{out}}

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