On this page:
2.2.1 Basic Images
circle
ellipse
line
add-line
add-curve
text
text/ font
bitmap
2.2.2 Polygons
triangle
right-triangle
isosceles-triangle
triangle/ sss
triangle/ ass
triangle/ sas
triangle/ ssa
triangle/ aas
triangle/ asa
triangle/ saa
square
rectangle
rhombus
star
star-polygon
radial-star
regular-polygon
polygon
2.2.3 Overlaying Images
overlay
overlay/ align
overlay/ xy
underlay
underlay/ align
underlay/ xy
beside
beside/ align
above
above/ align
2.2.4 Placing Images & Scenes
empty-scene
place-image
place-image/ align
scene+ line
scene+ curve
2.2.5 Rotating, Scaling, Flipping, Cropping, and Framing Images
rotate
scale
scale/ xy
flip-horizontal
flip-vertical
crop
frame
2.2.6 Image Properties
image-width
image-height
image-baseline
2.2.7 Image Predicates
image?
mode?
image-color?
color
y-place?
x-place?
angle?
side-count?
step-count?
pen
pen-style?
pen-cap?
pen-join?
2.2.8 Equality Testing of Images
2.2.9 The nitty gritty of pixels, pens, and lines
2.2.10 Exporting Images to Disk
save-image

2.2 Images: "image.ss"

 (require 2htdp/image)

The image teachpack provides a number of basic image construction functions, along with combinators for building more complex images out of existing images. Basic images include various polygons, ellipses and circles, and text, as well as bitmaps (typically bitmaps come about via the Insert Image... menu item in DrRacket). Existing images can be rotated, scaled, and overlaid on top of each other.

2.2.1 Basic Images

(circle radius mode color)  image?
  radius : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(circle radius outline-mode pen-or-color)  image?
  radius : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a circle with the given radius, height, mode, and color.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (circle 30 "outline" "red")
  
  > (circle 20 "solid" "blue")
  

(ellipse width height mode color)  image?
  width : (and/c real? (not/c negative?))
  height : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(ellipse width height mode pen-or-color)  image?
  width : (and/c real? (not/c negative?))
  height : (and/c real? (not/c negative?))
  mode : (or/c 'outline "outline")
  pen-or-color : (or/c image-color? pen?)
Constructs an ellipsis with the given width, height, mode, and color.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (ellipse 40 20 "outline" "black")
  
  > (ellipse 20 40 "solid" "blue")
  

(line x1 y1 pen-or-color)  image?
  x1 : real?
  y1 : real?
  pen-or-color : (or/c pen? image-color?)
Constructs an image representing a line segment that connects the points (0,0) to (x1,y1).

Examples:

  > (line 30 30 "black")
  
  > (line -30 20 "red")
  
  > (line 30 -20 "red")
  

(add-line image x1 y1 x2 y2 pen-or-color)  image?
  image : image?
  x1 : real?
  y1 : real?
  x2 : real?
  y2 : real?
  pen-or-color : (or/c pen? image-color?)
Adds a line to the image image, starting from the point (x1,y1) and going to the point (x2,y2). Unlike scene+line, if the line passes outside of image, the image gets larger to accomodate the line.

Examples:

  > (add-line (ellipse 40 40 "outline" "maroon")
              0 40 40 0 "maroon")
  
  > (add-line (rectangle 40 40 "solid" "gray")
              -10 50 50 -10 "maroon")
  
  > (add-line
      (rectangle 100 100 "solid" "darkolivegreen")
      25 25 75 75
      (make-pen "goldenrod" 30 "solid" "round" "round"))
  

(add-curve image    
  x1    
  y1    
  angle1    
  pull1    
  x2    
  y2    
  angle2    
  pull2    
  pen-or-color)  image?
  image : image?
  x1 : real?
  y1 : real?
  angle1 : angle?
  pull1 : real?
  x2 : real?
  y2 : real?
  angle2 : angle?
  pull2 : real?
  pen-or-color : (or/c pen? image-color?)
Adds a curve to image, starting at the point (x1,y1), and ending at the point (x2,y2).

The angle1 and angle2 arguments specify the angle that the curve has as it leaves the initial point and as it reaches the final point, respectively.

The pull1 and pull2 arguments control how long the curve tries to stay with that angle. Larger numbers mean that the curve stays with the angle longer.

Unlike scene+curve, if the line passes outside of image, the image gets larger to accomodate the curve.

Examples:

  > (add-curve (rectangle 100 100 "solid" "black")
               20 20 0 1/3
               80 80 0 1/3
               "white")
  
  > (add-curve (rectangle 100 100 "solid" "black")
               20 20 0 1
               80 80 0 1
               "white")
  
  > (add-curve
     (add-curve
      (rectangle 40 100 "solid" "black")
      20 10 180 1/2
      20 90 180 1/2
      (make-pen "white" 4 "solid" "round" "round"))
     20 10 0 1/2
     20 90 0 1/2
     (make-pen "white" 4 "solid" "round" "round"))
  
  > (add-curve (rectangle 100 100 "solid" "black")
               -20 -20 0 1
               120 120 0 1
               "red")
  

(text string font-size color)  image?
  string : string?
  font-size : (and/c integer? (<=/c 1 255))
  color : image-color?
Constructs an image that draws the given string, using the font size and color.

Examples:

  > (text "Hello" 24 "olive")
  
  > (text "Goodbye" 36 "indigo")
  

(text/font string    
  font-size    
  color    
  face    
  family    
  style    
  weight    
  underline?)  image?
  string : string?
  font-size : (and/c integer? (<=/c 1 255))
  color : image-color?
  face : (or/c string? #f)
  family : (or/c 'default 'decorative 'roman 'script 'swiss 'modern 'symbol 'system)
  style : (or/c 'normal 'italic 'slant)
  weight : (or/c 'normal 'bold 'light)
  underline? : any/c
Constructs an image that draws the given string, using a complete font specification.

The face and the family combine to give the complete typeface. If face is available on the system, it is used, but if not then a default typeface based on the family is chosen. The style controls if the face is italic or not (under Windows and Mac OS X, 'slant and 'italic are the same), the weight controls if it is boldface (or light), and underline? determines if the face is underlined. For more details on these arguments, see font%, which ultimately is what this code uses to draw the font.

Examples:

  > (text/font "Hello" 24 "olive"
               "Gill Sans" 'swiss 'normal 'bold #f)
  
  > (text/font "Goodbye" 18 "indigo"
               #f 'modern 'italic 'normal #f)
  
  > (text/font "not really a link" 18 "blue"
               #f 'roman 'normal 'normal #t)
  

(bitmap bitmap-spec)
 
bitmap-spec = rel-string
  | id
Loads the bitmap specified by bitmap-spec. If bitmap-spec is a string, it is treated as a relative path. If it is an identifier, it is treated like a require spec and used to refer to a file in a collection.

Examples:

  > (bitmap icons/stop-16x16.png)
  
  > (bitmap icons/b-run.png)
  

2.2.2 Polygons

(triangle side-length mode color)  image?
  side-length : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(triangle side-length    
  outline-mode    
  pen-or-color)  image?
  side-length : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a upward-pointing equilateral triangle. The side-length argument determines the length of the side of the triangle.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Example:

  > (triangle 40 "solid" "tan")
  

(right-triangle side-length1    
  side-length2    
  mode    
  color)  image?
  side-length1 : (and/c real? (not/c negative?))
  side-length2 : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(right-triangle side-length1    
  side-length2    
  outline-mode    
  pen-or-color)  image?
  side-length1 : (and/c real? (not/c negative?))
  side-length2 : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a triangle with a right angle where the two sides adjacent to the right angle have lengths side-length1 and side-length2.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Example:

  > (right-triangle 36 48 "solid" "black")
  

(isosceles-triangle side-length    
  angle    
  mode    
  color)  image?
  side-length : (and/c real? (not/c negative?))
  angle : angle?
  mode : mode?
  color : image-color?
(isosceles-triangle side-length    
  angle    
  outline-mode    
  pen-or-color)  image?
  side-length : (and/c real? (not/c negative?))
  angle : angle?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle with two equal-length sides, of length side-length where the angle between those sides is angle. The third leg is straight, horizontally. If the angle is less than 180, then the triangle will point up and if the angle is more, then the triangle will point down.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (isosceles-triangle 200 170 "solid" "seagreen")
  
  > (isosceles-triangle 60 30 "solid" "aquamarine")
  
  > (isosceles-triangle 60 330 "solid" "lightseagreen")
  

To create a general triangle given known sides and angles the following family of functions are useful: triangle/sss, triangle/ass, triangle/sas, triangle/ssa, triangle/sss, triangle/sss, and, triangle/sss. They all construct a triangle oriented as follows:

(triangle/sss side-length-a    
  side-length-b    
  side-length-c    
  mode    
  color)  image?
  side-length-a : (and/c real? (not/c negative?))
  side-length-b : (and/c real? (not/c negative?))
  side-length-c : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(triangle/sss side-length-a    
  side-length-b    
  side-length-c    
  outline-mode    
  pen-or-color)  image?
  side-length-a : (and/c real? (not/c negative?))
  side-length-b : (and/c real? (not/c negative?))
  side-length-c : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the side lengths a, b, and, c are given by side-length-a, side-length-b, and, side-length-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/sss 40 60 80 "solid" "seagreen")
  
  > (triangle/sss 80 40 60 "solid" "aquamarine")
  
  > (triangle/sss 80 80 40 "solid" "lightseagreen")
  

(triangle/ass angle-a    
  side-length-b    
  side-length-c    
  mode    
  color)  image?
  angle-a : angle?
  side-length-b : (and/c real? (not/c negative?))
  side-length-c : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(triangle/ass angle-a    
  side-length-b    
  side-length-c    
  outline-mode    
  pen-or-color)  image?
  angle-a : angle?
  side-length-b : (and/c real? (not/c negative?))
  side-length-c : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the angle A and side length a and b, are given by angle-a, side-length-b, and, side-length-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/ass 10  60 100 "solid" "seagreen")
  
  > (triangle/ass 90  60 100 "solid" "aquamarine")
  
  > (triangle/ass 130 60 100 "solid" "lightseagreen")
  

(triangle/sas side-length-a    
  angle-b    
  side-length-c    
  mode    
  color)  image?
  side-length-a : (and/c real? (not/c negative?))
  angle-b : angle?
  side-length-c : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(triangle/sas side-length-a    
  angle-b    
  side-length-c    
  outline-mode    
  pen-or-color)  image?
  side-length-a : (and/c real? (not/c negative?))
  angle-b : angle?
  side-length-c : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the side length a, angle B, and, side length c given by side-length-a, angle-b, and, side-length-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/sas 60  10 100 "solid" "seagreen")
  
  > (triangle/sas 60  90 100 "solid" "aquamarine")
  
  > (triangle/sas 60 130 100 "solid" "lightseagreen")
  

(triangle/ssa side-length-a    
  side-length-b    
  angle-c    
  mode    
  color)  image?
  side-length-a : (and/c real? (not/c negative?))
  side-length-b : (and/c real? (not/c negative?))
  angle-c : angle?
  mode : mode?
  color : image-color?
(triangle/ssa side-length-a    
  side-length-b    
  angle-c    
  outline-mode    
  pen-or-color)  image?
  side-length-a : (and/c real? (not/c negative?))
  side-length-b : (and/c real? (not/c negative?))
  angle-c : angle?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the side length a, side length b, and, angle c given by side-length-a, side-length-b, and, angle-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/ssa 60 100  10 "solid" "seagreen")
  
  > (triangle/ssa 60 100  90 "solid" "aquamarine")
  
  > (triangle/ssa 60 100 130 "solid" "lightseagreen")
  
(triangle/aas angle-a    
  angle-b    
  side-length-c    
  mode    
  color)  image?
  angle-a : angle?
  angle-b : angle?
  side-length-c : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(triangle/aas angle-a    
  angle-b    
  side-length-c    
  outline-mode    
  pen-or-color)  image?
  angle-a : angle?
  angle-b : angle?
  side-length-c : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the angle A, angle B, and, side length c given by angle-a, angle-b, and, side-length-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/aas  10 40 200 "solid" "seagreen")
  
  > (triangle/aas  90 40 200 "solid" "aquamarine")
  
  > (triangle/aas 130 40 40  "solid" "lightseagreen")
  

(triangle/asa angle-a    
  side-length-b    
  angle-c    
  mode    
  color)  image?
  angle-a : angle?
  side-length-b : (and/c real? (not/c negative?))
  angle-c : angle?
  mode : mode?
  color : image-color?
(triangle/asa angle-a    
  side-length-b    
  angle-c    
  outline-mode    
  pen-or-color)  image?
  angle-a : angle?
  side-length-b : (and/c real? (not/c negative?))
  angle-c : angle?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the angle A, side length b, and, angle C given by angle-a, side-length-b, and, angle-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/asa  10 200 40 "solid" "seagreen")
  
  > (triangle/asa  90 200 40 "solid" "aquamarine")
  
  > (triangle/asa 130 40  40 "solid" "lightseagreen")
  

(triangle/saa side-length-a    
  angle-b    
  angle-c    
  mode    
  color)  image?
  side-length-a : (and/c real? (not/c negative?))
  angle-b : angle?
  angle-c : angle?
  mode : mode?
  color : image-color?
(triangle/saa side-length-a    
  angle-b    
  angle-c    
  outline-mode    
  pen-or-color)  image?
  side-length-a : (and/c real? (not/c negative?))
  angle-b : angle?
  angle-c : angle?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Creates a triangle where the side length a, angle B, and, angle C given by side-length-a, angle-b, and, angle-c respectively.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (triangle/saa 200  10 40 "solid" "seagreen")
  
  > (triangle/saa 200  90 40 "solid" "aquamarine")
  
  > (triangle/saa 40  130 40 "solid" "lightseagreen")
  

(square side-len mode color)  image?
  side-len : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(square side-len outline-mode pen-or-color)  image?
  side-len : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a square.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (square 40 "solid" "slateblue")
  
  > (square 50 "outline" "darkmagenta")
  

(rectangle width height mode color)  image?
  width : real?
  height : real?
  mode : mode?
  color : image-color?
(rectangle width    
  height    
  outline-mode    
  pen-or-color)  image?
  width : real?
  height : real?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a rectangle with the given width, height, mode, and color.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (rectangle 40 20 "outline" "black")
  
  > (rectangle 20 40 "solid" "blue")
  

(rhombus side-length angle mode color)  image?
  side-length : (and/c real? (not/c negative?))
  angle : angle?
  mode : mode?
  color : image-color?
(rhombus side-length    
  angle    
  outline-mode    
  pen-or-color)  image?
  side-length : (and/c real? (not/c negative?))
  angle : angle?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a four sided polygon with all equal sides and thus where opposite angles are equal to each other. The top and bottom pair of angles is angle and the left and right are (- 180 angle).

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (rhombus 40 45 "solid" "magenta")
  
  > (rhombus 80 150 "solid" "mediumpurple")
  

(star side-length mode color)  image?
  side-length : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(star side-length outline-mode color)  image?
  side-length : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  color : (or/c pen? image-color?)
Constructs a star with five points. The side-length argument determines the side length of the enclosing pentagon.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Example:

  > (star 40 "solid" "gray")
  

(star-polygon side-length    
  side-count    
  step-count    
  mode    
  color)  image?
  side-length : (and/c real? (not/c negative?))
  side-count : side-count?
  step-count : step-count?
  mode : mode?
  color : image-color?
(star-polygon side-length    
  side-count    
  step-count    
  outline-mode    
  pen-or-color)  image?
  side-length : (and/c real? (not/c negative?))
  side-count : side-count?
  step-count : step-count?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs an arbitrary regular star polygon (a generalization of the regular polygons). The polygon is enclosed by a regular polygon with side-count sides each side-length long. The polygon is actually constructed by going from vertex to vertex around the regular polgon, but skipping over every step-count vertices.

For examples, if side-count is 5 and step-count is 2, then this function produces a shape just like star.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (star-polygon 40 5 2 "solid" "seagreen")
  
  > (star-polygon 40 7 3 "outline" "darkred")
  
  > (star-polygon 20 10 3 "solid" "cornflowerblue")
  

(radial-star point-count    
  inner-radius    
  outer-radius    
  mode    
  color)  image?
  point-count : (and/c integer? (>=/c 2))
  inner-radius : (and/c real? (not/c negative?))
  outer-radius : (and/c real? (not/c negative?))
  mode : mode?
  color : image-color?
(radial-star point-count    
  inner-radius    
  outer-radius    
  outline-mode    
  pen-or-color)  image?
  point-count : (and/c integer? (>=/c 2))
  inner-radius : (and/c real? (not/c negative?))
  outer-radius : (and/c real? (not/c negative?))
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a star-like polygon where the star is specified by two radii and a number of points. The first radius determines where the points begin, the second determines where they end, and the point-count argument determines how many points the star has.

Examples:

  > (radial-star 8 8 64 "solid" "darkslategray")
  
  > (radial-star 32 30 40 "outline" "black")
  

(regular-polygon side-length    
  side-count    
  mode    
  color)  image?
  side-length : (and/c real? (not/c negative?))
  side-count : side-count?
  mode : mode?
  color : image-color?
(regular-polygon side-length    
  side-count    
  outline-mode    
  pen-or-color)  image?
  side-length : (and/c real? (not/c negative?))
  side-count : side-count?
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a regular polygon with side-count sides.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (regular-polygon 50 3 "outline" "red")
  
  > (regular-polygon 40 4 "outline" "blue")
  
  > (regular-polygon 20 8 "solid" "red")
  

(polygon vertices mode color)  image?
  vertices : (listof posn?)
  mode : mode?
  color : image-color?
(polygon vertices outline-mode pen-or-color)  image?
  vertices : (listof posn?)
  outline-mode : (or/c 'outline "outline")
  pen-or-color : (or/c pen? image-color?)
Constructs a polygon connecting the given vertices.

If the mode is 'outline or "outline", then the last argument can be a pen struct or an image-color?, but if the mode is 'solid or "solid", then the last argument must be an image-color?.

Examples:

  > (polygon (list (make-posn 0 0)
                   (make-posn -10 20)
                   (make-posn 60 0)
                   (make-posn -10 -20))
             "solid"
             "burlywood")
  
  > (polygon (list (make-posn 0 0)
                   (make-posn 0 40)
                   (make-posn 20 40)
                   (make-posn 20 60)
                   (make-posn 40 60)
                   (make-posn 40 20)
                   (make-posn 20 20)
                   (make-posn 20 0))
             "solid"
             "plum")
  
  > (underlay
     (rectangle 80 80 "solid" "mediumseagreen")
     (polygon
      (list (make-posn 0 0)
            (make-posn 50 0)
            (make-posn 0 50)
            (make-posn 50 50))
      "outline"
      (make-pen "darkslategray" 10 "solid" "round" "round")))
  
  > (underlay
     (rectangle 90 80 "solid" "mediumseagreen")
     (polygon
      (list (make-posn 0 0)
            (make-posn 50 0)
            (make-posn 0 50)
            (make-posn 50 50))
      "outline"
      (make-pen "darkslategray" 10 "solid" "projecting" "miter")))
  

2.2.3 Overlaying Images

(overlay i1 i2 is ...)  image?
  i1 : image?
  i2 : image?
  is : image?
Overlays all of its arguments building a single image. The first argument goes on top of the second argument, which goes on top of the third argument, etc. The images are all lined up on their centers.

Examples:

  > (overlay (rectangle 30 60 "solid" "orange")
             (ellipse 60 30 "solid" "purple"))
  
  > (overlay (ellipse 10 10 "solid" "red")
             (ellipse 20 20 "solid" "black")
             (ellipse 30 30 "solid" "red")
             (ellipse 40 40 "solid" "black")
             (ellipse 50 50 "solid" "red")
             (ellipse 60 60 "solid" "black"))
  
  > (overlay (regular-polygon 20 5 "solid" (make-color  50  50 255))
             (regular-polygon 26 5 "solid" (make-color 100 100 255))
             (regular-polygon 32 5 "solid" (make-color 150 150 255))
             (regular-polygon 38 5 "solid" (make-color 200 200 255))
             (regular-polygon 44 5 "solid" (make-color 250 250 255)))
  

(overlay/align x-place y-place i1 i2 is ...)  image?
  x-place : x-place?
  y-place : y-place?
  i1 : image?
  i2 : image?
  is : image?
Overlays all of its image arguments, much like the overlay function, but using x-place and y-place to determine where the images are lined up. For example, if x-place and y-place are both "middle", then the images are lined up on their centers.

Examples:

  > (overlay/align "left" "middle"
                   (rectangle 30 60 "solid" "orange")
                   (ellipse 60 30 "solid" "purple"))
  
  > (overlay/align "right" "bottom"
                   (rectangle 20 20 "solid" "silver")
                   (rectangle 30 30 "solid" "seagreen")
                   (rectangle 40 40 "solid" "silver")
                   (rectangle 50 50 "solid" "seagreen"))
  

(overlay/xy i1 x y i2)  image?
  i1 : image?
  x : real?
  y : real?
  i2 : image?
Constructs an image by overlaying i1 on top of i2 after shifting i2 over by x pixels to the right and y pixels down.

Examples:

  > (overlay/xy (rectangle 20 20 "outline" "black")
                20 0
                (rectangle 20 20 "outline" "black"))
  
  > (overlay/xy (rectangle 20 20 "solid" "red")
                20 20
                (rectangle 20 20 "solid" "black"))
  
  > (overlay/xy (rectangle 20 20 "solid" "red")
                -20 -20
                (rectangle 20 20 "solid" "black"))
  
  > (overlay/xy
     (overlay/xy (ellipse 40 40 "outline" "black")
                 10
                 15
                 (ellipse 10 10 "solid" "forestgreen"))
     20
     15
     (ellipse 10 10 "solid" "forestgreen"))
  

(underlay i1 i2 is ...)  image?
  i1 : image?
  i2 : image?
  is : image?
Underlays all of its arguments building a single image.

It behaves like overlay, but with the arguments in the reverse order. That is, the first argument goes underneath of the second argument, which goes underneath the third argument, etc. The images are all lined up on their centers.

Examples:

  > (underlay (rectangle 30 60 "solid" "orange")
              (ellipse 60 30 "solid" "purple"))
  
  > (underlay (ellipse 10 60 "solid" "red")
              (ellipse 20 50 "solid" "black")
              (ellipse 30 40 "solid" "red")
              (ellipse 40 30 "solid" "black")
              (ellipse 50 20 "solid" "red")
              (ellipse 60 10 "solid" "black"))
  

(underlay/align x-place y-place i1 i2 is ...)  image?
  x-place : x-place?
  y-place : y-place?
  i1 : image?
  i2 : image?
  is : image?
Underlays all of its image arguments, much like the underlay function, but using x-place and y-place to determine where the images are lined up. For example, if x-place and y-place are both "middle", then the images are lined up on their centers.

Examples:

  > (underlay/align "left" "middle"
                    (rectangle 30 60 "solid" "orange")
                    (ellipse 60 30 "solid" "purple"))
  
  > (underlay/align "right" "top"
                    (rectangle 50 50 "solid" "seagreen")
                    (rectangle 40 40 "solid" "silver")
                    (rectangle 30 30 "solid" "seagreen")
                    (rectangle 20 20 "solid" "silver"))
  

(underlay/xy i1 x y i2)  image?
  i1 : image?
  x : real?
  y : real?
  i2 : image?
Constructs an image by underlaying i1 underneath of i2 after shifting i2 over by x pixels to the right and y pixels down.

This is the same as (overlay/xy i2 (- x) (- y) i1).

Examples:

  > (underlay/xy (rectangle 20 20 "outline" "black")
                 20 0
                 (rectangle 20 20 "outline" "black"))
  
  > (underlay/xy (rectangle 20 20 "solid" "red")
                 20 20
                 (rectangle 20 20 "solid" "black"))
  
  > (underlay/xy (rectangle 20 20 "solid" "red")
                 -20 -20
                 (rectangle 20 20 "solid" "black"))
  
  > (underlay/xy
     (underlay/xy (ellipse 40 40 "solid" "gray")
                  10
                  15
                  (ellipse 10 10 "solid" "forestgreen"))
     20
     15
     (ellipse 10 10 "solid" "forestgreen"))
  

(beside i1 i2 is ...)  image?
  i1 : image?
  i2 : image?
  is : image?
Constructs an image by placing all of the argument images in a horizontal row, aligned along their centers.

Example:

  > (beside (ellipse 20 70 "solid" "gray")
            (ellipse 20 50 "solid" "darkgray")
            (ellipse 20 30 "solid" "dimgray")
            (ellipse 20 10 "solid" "black"))
  

(beside/align y-place i1 i2 is ...)  image?
  y-place : y-place?
  i1 : image?
  i2 : image?
  is : image?
Constructs an image by placing all of the argument images in a horizontal row, lined up as indicated by the y-place argument. For example, if y-place is "middle", then the images are placed side by side with their centers lined up with each other.

Examples:

  > (beside/align "bottom"
                  (ellipse 20 70 "solid" "lightsteelblue")
                  (ellipse 20 50 "solid" "mediumslateblue")
                  (ellipse 20 30 "solid" "slateblue")
                  (ellipse 20 10 "solid" "navy"))
  
  > (beside/align "top"
                  (ellipse 20 70 "solid" "mediumorchid")
                  (ellipse 20 50 "solid" "darkorchid")
                  (ellipse 20 30 "solid" "purple")
                  (ellipse 20 10 "solid" "indigo"))
  
  > (beside/align "baseline"
                  (text "ijy" 18 "black")
                  (text "ijy" 24 "black"))
  

(above i1 i2 is ...)  image?
  i1 : image?
  i2 : image?
  is : image?
Constructs an image by placing all of the argument images in a vertical row, aligned along their centers.

Example:

  > (above (ellipse 70 20 "solid" "gray")
           (ellipse 50 20 "solid" "darkgray")
           (ellipse 30 20 "solid" "dimgray")
           (ellipse 10 20 "solid" "black"))
  

(above/align x-place i1 i2 is ...)  image?
  x-place : x-place?
  i1 : image?
  i2 : image?
  is : image?
Constructs an image by placing all of the argument images in a vertical row, lined up as indicated by the x-place argument. For example, if x-place is "middle", then the images are placed above each other with their centers lined up.

Examples:

  > (above/align "right"
                 (ellipse 70 20 "solid" "gold")
                 (ellipse 50 20 "solid" "goldenrod")
                 (ellipse 30 20 "solid" "darkgoldenrod")
                 (ellipse 10 20 "solid" "sienna"))
  
  > (above/align "left"
                 (ellipse 70 20 "solid" "yellowgreen")
                 (ellipse 50 20 "solid" "olivedrab")
                 (ellipse 30 20 "solid" "darkolivegreen")
                 (ellipse 10 20 "solid" "darkgreen"))
  

2.2.4 Placing Images & Scenes

Placing images into scenes is particularly useful when building worlds and universes using 2htdp/universe.

(empty-scene width height)  image?
  width : (and/c real? (not/c negative?))
  height : (and/c real? (not/c negative?))
Creates an empty scene, i.e., a rectangle with a black outline.

Example:

  > (empty-scene 160 90)
  

(place-image image x y scene)  image?
  image : image?
  x : real?
  y : real?
  scene : image?
Places image onto scene with its center at the coordinates (x,y) and crops the resulting image so that it has the same size as scene. The coordinates are relative to the top-left of scene.

Examples:

  > (place-image
     (triangle 32 "solid" "red")
     24 24
     (rectangle 48 48 "solid" "gray"))
  
  > (place-image
     (triangle 64 "solid" "red")
     24 24
     (rectangle 48 48 "solid" "gray"))
  
  > (place-image
     (circle 4 "solid" "white")
     18 20
     (place-image
      (circle 4 "solid" "white")
      0 6
      (place-image
       (circle 4 "solid" "white")
       14 2
       (place-image
        (circle 4 "solid" "white")
        8 14
        (rectangle 24 24 "solid" "goldenrod")))))
  
(place-image/align image    
  x    
  y    
  x-place    
  y-place    
  scene)  image?
  image : image?
  x : real?
  y : real?
  x-place : x-place?
  y-place : y-place?
  scene : image?
Like place-image, but uses image’s x-place and y-place to anchor the image. Also, like place-image, place-image/align crops the resulting image so that it has the same size as scene.

Examples:

  > (place-image/align (triangle 48 "solid" "yellowgreen")
                       64 64 "right" "bottom"
                       (rectangle 64 64 "solid" "mediumgoldenrod"))
  
  > (beside
     (place-image/align (circle 8 "solid" "tomato")
                        0 0 "center" "center"
                        (rectangle 32 32 "outline" "black"))
     (place-image/align (circle 8 "solid" "tomato")
                        8 8 "center" "center"
                        (rectangle 32 32 "outline" "black"))
     (place-image/align (circle 8 "solid" "tomato")
                        16 16 "center" "center"
                        (rectangle 32 32 "outline" "black"))
     (place-image/align (circle 8 "solid" "tomato")
                        24 24 "center" "center"
                        (rectangle 32 32 "outline" "black"))
     (place-image/align (circle 8 "solid" "tomato")
                        32 32 "center" "center"
                        (rectangle 32 32 "outline" "black")))
  

(scene+line image x1 y1 x2 y2 color)  image?
  image : image?
  x1 : real?
  y1 : real?
  x2 : real?
  y2 : real?
  color : image-color?
Adds a line to the image scene, starting from the point (x1,y1) and going to the point (x2,y2); unlike add-line, this function crops the resulting image to the size of scene.

Examples:

  > (scene+line (ellipse 40 40 "outline" "maroon")
                0 40 40 0 "maroon")
  
  > (scene+line (rectangle 40 40 "solid" "gray")
                -10 50 50 -10 "maroon")
  
  > (scene+line
     (rectangle 100 100 "solid" "darkolivegreen")
     25 25 100 100
     (make-pen "goldenrod" 30 "solid" "round" "round"))
  

(scene+curve scene    
  x1    
  y1    
  angle1    
  pull1    
  x2    
  y2    
  angle2    
  pull2    
  color)  image?
  scene : image?
  x1 : real?
  y1 : real?
  angle1 : angle?
  pull1 : real?
  x2 : real?
  y2 : real?
  angle2 : angle?
  pull2 : real?
  color : image-color?
Adds a curve to scene, starting at the point (x1,y1), and ending at the point (x2,y2).

The angle1 and angle2 arguments specify the angle that the curve has as it leaves the initial point and as it reaches the final point, respectively.

The pull1 and pull2 arguments control how long the curve tries to stay with that angle. Larger numbers mean that the curve stays with the angle longer.

Unlike add-curve, this function crops the curve, only showing the parts that fit onto scene.

Examples:

  > (scene+curve (rectangle 100 100 "solid" "black")
                 20 20 0 1/3
                 80 80 0 1/3
                 "white")
  
  > (scene+curve (rectangle 100 100 "solid" "black")
                 20 20 0 1
                 80 80 0 1
                 "white")
  
  > (scene+curve
     (add-curve
      (rectangle 40 100 "solid" "black")
      20 10 180 1/2
      20 90 180 1/2
      "white")
     20 10 0 1/2
     20 90 0 1/2
     "white")
  
  > (scene+curve (rectangle 100 100 "solid" "black")
                 -20 -20 0 1
                 120 120 0 1
                 "red")
  

2.2.5 Rotating, Scaling, Flipping, Cropping, and Framing Images

(rotate angle image)  image?
  angle : angle?
  image : image?
Rotates image by angle degrees in a counter-clockwise direction.

Examples:

  > (rotate 45 (ellipse 60 20 "solid" "olivedrab"))
  
  > (rotate 5 (rectangle 50 50 "outline" "black"))
  
  > (rotate 45
            (beside/align
             "center"
             (rectangle 40 20 "solid" "darkseagreen")
             (rectangle 20 100 "solid" "darkseagreen")))
  

(scale factor image)  image?
  factor : (and/c real? positive?)
  image : image?
Scales image by factor.

The pen sizes are also scaled and thus draw thicker (or thinner) lines than the original image, unless the pen was size 0. That pen size is treated specially to mean “the smallest available line” and thus it always draws a one pixel wide line; this is also the case for 'outline and "outline" shapes that are drawn with an image-color? instead of a pen.

Examples:

  > (scale 2 (ellipse 20 30 "solid" "blue"))
  
  > (ellipse 40 60 "solid" "blue")
  

(scale/xy x-factor y-factor image)  image?
  x-factor : (and/c real? positive?)
  y-factor : (and/c real? positive?)
  image : image?
Scales image by x-factor horizontally and by y-factor vertically.

Examples:

  > (scale/xy 3
              2
              (ellipse 20 30 "solid" "blue"))
  
  > (ellipse 60 60 "solid" "blue")
  

(flip-horizontal image)  image?
  image : image?
Flips image left to right.

Flipping images with text is not supported (so passing flip-horizontal an image that contains a text or text/font image inside somewhere signals an error).

Example:

  > (beside
     (rotate 30 (square 50 "solid" "red"))
     (flip-horizontal
      (rotate 30 (square 50 "solid" "blue"))))
  

(flip-vertical image)  image?
  image : image?
Flips image top to bottom.

Flipping images with text is not supported (so passing flip-horizontal an image that contains a text or text/font image inside somewhere signals an error).

Example:

  > (above
     (star 40 "solid" "firebrick")
     (scale/xy 1 1/2 (flip-vertical (star 40 "solid" "gray"))))
  

(crop x y width height image)  image?
  x : (and/c real? (between/c 0 (image-width image)))
  y : (and/c real? (between/c 0 (image-height image)))
  width : (and/c real? (not/c negative?))
  height : (and/c real? (not/c negative?))
  image : image?
Crops image to the rectangle with the upper left at the point (x,y) and with width and height.

The x and y arguments must be between 0 and the width or height, respectively.

Examples:

  > (crop 0 0 40 40 (circle 40 "solid" "chocolate"))
  
  > (crop 40 60 40 60 (ellipse 80 120 "solid" "dodgerblue"))
  
  > (above
     (beside (crop 40 40 40 40 (circle 40 "solid" "palevioletred"))
             (crop 0 40 40 40 (circle 40 "solid" "lightcoral")))
     (beside (crop 40 0 40 40 (circle 40 "solid" "lightcoral"))
             (crop 0 0 40 40 (circle 40 "solid" "palevioletred"))))
  

(frame image)  image?
  image : image?
Returns an image just like image, except with a black, single pixel frame drawn around the bounding box of the image.

Example:

  > (frame (ellipse 20 20 "outline" "black"))
  

Generally speaking, this function is useful to debug image constructions, i.e., to see where certain sub-images appear within some larger image.

Example:

  > (beside
     (ellipse 20 70 "solid" "lightsteelblue")
     (frame (ellipse 20 50 "solid" "mediumslateblue"))
     (ellipse 20 30 "solid" "slateblue")
     (ellipse 20 10 "solid" "navy"))
  

2.2.6 Image Properties

(image-width i)  (and/c integer? (not/c negative?) exact?)
  i : image?
Returns the width of i.

Examples:

  > (image-width (ellipse 30 40 "solid" "orange"))
  30
  > (image-width (circle 30 "solid" "orange"))
  60
  > (image-width (beside (circle 20 "solid" "orange")
                         (circle 20 "solid" "purple")))
  80
  > (image-width (rectangle 0 10 "solid" "purple"))
  0

(image-height i)  (and/c integer? (not/c negative?) exact?)
  i : image?
Returns the height of i.

Examples:

  > (image-height (ellipse 30 40 "solid" "orange"))
  40
  > (image-height (circle 30 "solid" "orange"))
  60
  > (image-height (overlay (circle 20 "solid" "orange")
                           (circle 30 "solid" "purple")))
  60
  > (image-height (rectangle 10 0 "solid" "purple"))
  0

Returns the distance from the top of the image to its baseline. Unless the image was constructed with text or text/font, this will be the same as its height.

Examples:

  > (image-baseline (text "Hello" 24 "black"))
  18
  > (image-height (text "Hello" 24 "black"))
  24
  > (image-baseline (rectangle 100 100 "solid" "black"))
  100
  > (image-height (rectangle 100 100 "solid" "black"))
  100

2.2.7 Image Predicates

This section lists predicates for the basic structures provided by the image library.

(image? x)  boolean?
  x : any/c
Determines if x is an image. Images are returned by functions like ellipse and rectangle and accepted by functions like overlay and beside.

Additionally, images inserted into a DrRacket window are treated as bitmap images, as are instances of image-snip% and bitmap%.

(