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

{{trans|Python}}

 

Byte r, g, b

 

V bitmap = Bitmap(17, 17)

bitmap.cubicbezier(16, 1, 1, 4, 3, 16, 15, 11)

 

{{out}}

{{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_cubic.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

( Picture : in out Image;

P1, P2, P3, P4 : Point;

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

end loop;

The following test

begin

Fill (X, White);

Cubic_Bezier (X, (16, 1), (1, 4), (3, 16), (15, 11), Black);

should produce output:

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

cubic bezier OF class image :=

END # cubic bezier #;

 

# -*- coding: utf-8 -*- #

(cubic bezier OF class image)(x, (16, 1), (1, 4), (3, 16), (15, 11), (black OF class image), EMPTY);

(print OF class image) (x)

<pre>

ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

{{works with|BBC BASIC for Windows}}

[[Image:beziercubic_bbc.gif|right]]

Height% = 200

GCOL 1

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

 

=={{header|C}}==

"Interface" <tt>imglib.h</tt>.

 

image img,

unsigned int x1, unsigned int y1,

color_component r,

color_component g,

 

 

/* number of segments for the curve */

}

#undef plot

 

=={{header|D}}==

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

 

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

Gray.black);

im.textualShow();

{{out}}

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

 

=={{header|F Sharp|F#}}==

/// Uses Vector<float> from Microsoft.FSharp.Math (in F# PowerPack)

module CubicBezier

vector [x; y])

 

// For rendering..

let drawPoints points (canvas:System.Windows.Controls.Canvas) =

 

points |> List.fold renderPoint points.Head

 

=={{header|Factor}}==

The points should probably be in a sequence...

rosettacode.raster.storage sequences ;

IN: rosettacode.raster.line

100 t-interval P0 P1 P2 P3 (cubic-bezier) map

points-to-lines

 

=={{header|FBSL}}==

 

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

#DEFINE WM_CLOSE 16

 

WEND

END SUB

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

 

This subroutine should go inside the <code>RCImagePrimitive</code> module (see [[Bresenham's line algorithm]])

 

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

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

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 b3Seg = 30

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

b.Bézier3(x1, y1, x2, y2, x3, y3, x4, y4, c.Pixel())

Demonstration program:

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

 

import (

fmt.Println(err)

}

 

=={{header|J}}==

See the [[J:Essays/Bernstein Polynomials|Bernstein Polynomials essay]] on the [[J:|J Wiki]].<br>

Uses code from [[Basic_bitmap_storage#J|Basic bitmap storage]], [[Bresenham's_line_algorithm#J|Bresenham's line algorithm]] and [[Midpoint_circle_algorithm#J|Midpoint circle algorithm]].

 

bik=: 2 : '((*&(u!v))@(^&u * ^&(v-u)@-.))'

NB. eg: (42 40 10 30 186 269 26 187;255 0 0) drawBezier myimg

NB. x is: 2-item list of boxed (controlpoints) ; (color)

 

'''Example usage:'''

]randomctrlpts=: ,3 2 ?@$ }:$ myimg NB. 3 control points - quadratic

]randomctrlpts=: ,4 2 ?@$ }:$ myimg NB. 4 control points - cubic

myimg=: ((2 ,.~ _2]\randomctrlpts);255 0 255) drawCircles myimg NB. draw control points

 

=={{header|JavaScript}}==

function draw() {

var canvas = document.getElementById("container");

context.fill();

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

function cubicbezier!(xy::Matrix,

 

xy = [16 1; 1 4; 3 16; 15 11]

 

=={{header|Kotlin}}==

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

 

import java.awt.Color

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

}

 

=={{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:cubicbezier( 1,1, 15,41, 45,-20, 59,19 )

{{out}}

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

 

=={{header|Lambdatalk}}==

Drawing a cubic bezier curve out of any SVG or CANVAS frame.

1) interpolating 4 points

The result can be seen in http://lambdaway.free.fr/lambdawalks/?view=bezier

 

 

 

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

[[File:MmaCubicBezier.png]]

 

=={{header|MATLAB}}==

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

function bezierCubic(obj,pixel_0,pixel_1,pixel_2,pixel_3,color,varargin)

 

end

 

Sample usage:

This will generate the image example for the PHP solution.

>> img = Bitmap(200,200);

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

>> img.bezierCubic([160 10],[10 40],[30 160],[150 110],[255 0 0],110);

>> 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.drawCubicBezier((0, 15), (3, 0), (15, 2), (10, 14), 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]], 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][200] = red

img[300][100] = red

 

=={{header|PHP}}==

Outputs image to the right directly to browser or stdout.

 

 

$image = imagecreate(200, 200);

}

}

 

=={{header|PicoLisp}}==

This uses the 'brez' line drawing function from

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

 

(de cubicBezier (Img N X1 Y1 X2 Y2 X3 Y3 X4 Y4)

Y ) ) )

(inc 'X DX)

Test:

(cubicBezier Img 24 20 120 540 33 -225 33 285 100)

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

(mapc prinl Img) ) )

 

 

=={{header|Processing}}==

bezier(85, 20, 10, 10, 90, 90, 15, 80);

/*

Can also be drawn in 3D.

bezier(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4)

 

'''It can be run on line''' :<BR> [https://www.openprocessing.org/sketch/846556/ here.]

float[] x = new float[4];

float[] y = new float[4];

}

}

 

=={{header|PureBasic}}==

Protected i

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

Repeat

event = WaitWindowEvent()

 

=={{header|Python}}==

 

Extending the example given [[Bresenham's line algorithm#Python|here]] and using the algorithm from the C solution above:

pts = []

for i in range(n+1):

| |

+-----------------+

 

=={{header|R}}==

# n: the number of points in the curve.

bezierCurve <- function(x, y, n=10)

y <- 1:6

plot(x, y, "o", pch=20)

 

=={{header|Racket}}==

#lang racket

(require racket/draw)

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

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-cubic-perl6.png example image here], (converted to a .png as .ppm format is not widely supported).

Requires code from the [[Bitmap#Ruby|Bitmap]] and [[Bitmap/Bresenham's line algorithm#Ruby Bresenham's line algorithm]] tasks

 

def draw_bezier_curve(points, colour)

# ensure the points are increasing along the x-axis

]

points.each {|p| bitmap.draw_circle(p, 3, RGBColour::RED)}

 

=={{header|Tcl}}==

{{libheader|Tk}}

This solution can be applied to any number of points. Uses code from [[Basic_bitmap_storage#Tcl|Basic bitmap storage]] (<tt>newImage</tt>, <tt>fill</tt>), [[Bresenham's_line_algorithm#Tcl|Bresenham's line algorithm]] (<tt>drawLine</tt>), and [[Midpoint_circle_algorithm#Tcl|Midpoint circle algorithm]] (<tt>drawCircle</tt>)

package require Tk

 

button .new -command [list newbezier $degree .img] -text New

button .exit -command exit -text Exit

Results in:

 

{{TI-image-task}}

 

Local i,t,u,prev,pt

0 → pt

EndIf

EndFor

 

=={{header|Wren}}==

{{libheader|DOME}}

Requires version 1.3.0 of DOME or later.

import "dome" for Window

 

 

static draw(alpha) {}

 

=={{header|XPL0}}==

[[File:CubicXPL0.png|right]]

 

proc Bezier(P0, P1, P2, P3); \Draw cubic 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.cBezier(0,149, 30,50, 120,130, 160,30, 0);

 

{{omit from|AWK}}