Images in General, Images in OpenGL - PowerPoint PPT Presentation

Loading...

PPT – Images in General, Images in OpenGL PowerPoint presentation | free to view - id: 1effbe-ZDc1Z



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Images in General, Images in OpenGL

Description:

A raster image (or image or pixel rectangle or pixmap) is a 2-D array ... legal! ... Yfactor: Vertical zoom factor. Floating point. 24 Nov 2003. CS 381. 19 ... – PowerPoint PPT presentation

Number of Views:111
Avg rating:3.0/5.0
Slides: 22
Provided by: glenngc
Category:
Tags: opengl | general | images | legal | zoom

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Images in General, Images in OpenGL


1
Images in General,Images in OpenGL
  • Glenn G. ChappellCHAPPELLG_at_member.ams.org
  • U. of Alaska Fairbanks
  • CS 381 Lecture Notes
  • Monday, November 24, 2003

2
ReviewImage Basics 1/2
  • A raster image (or image or pixel rectangle or
    pixmap) is a 2-D array of color values.
  • OpenGL (along with other graphics libraries)
    provides the following types of primitives
  • Points.
  • Polylines.
  • Filled polygons.
  • Raster images.
  • Bitmaps.
  • Two Pipelines
  • The geometry pipeline handles the first three.
  • The image pipeline handles the last two.

3
ReviewImage Basics 2/2
  • Top geometry pipeline. Bottom image pipeline.
  • This is a huge over-simplification, as usual.
  • The image pipeline has the same data type at
    start end.
  • So it can run backwards.

VertexOperations
FrameBuffer
VertexData
Vertex
Fragments
Vertex
Rasterization
FragmentOperations
Fragment
Fragment
Pixmap
Pixmap
PixelOperations
PixelData
Pixmap
Pixmap
4
Images in GeneralBuffers
  • In CG, a (2-D) buffer is a block of memory,
    arranged as a 2-D array.
  • Width and height correspond to the size of some
    image (the viewport?).
  • Often it is convenient to implement conceptually
    different buffers as a single buffer in which
    each element is essentially a packed struct.
  • OpenGL buffers are generally done this way.
  • Each conceptual buffer occupies different
    bitplanes in the buffer as a whole.
  • See page 306 in the blue book for an
    illustration.
  • So an image in the frame buffer may be stored in
    a very different format from images accessible to
    the application.

5
Images in GeneralImages in an Application
  • Images managed by an application are stored in
    arraysconst int img_width 200 // Sometimes
    these needconst int img_height 100 // to be
    powers of 2.color imgheightwidth //
    Height first! (Why?)
  • color above is usually an array of 3 or 4
    GLubytesGLubyte img_rgbimg_heightimg_width
    3GLubyte img_rgbaimg_heightimg_width4
  • Here, each GLubyte is a number from 0 to 255. So
    multiply colors in 0..1 format by 255 before
    storing them in the array.
  • Grayscale (luminance) images may require only
    one number for the colorGLubyte
    img_lumimg_heightimg_width

6
Images in GeneralImages in Files
  • Images stored in files are usually compressed in
    some way.
  • Some of these compression techniques are very
    complex, and therefore difficult to read.
  • We will not have time to look much into image
    file formats this semester.
  • If you want to read an image file, go ahead and
    use someone elses code.
  • Make sure its legal!
  • And find the code before you spend a lot of time
    writing a program that requires it.

7
Images in GeneralBITBLT
  • Copying and rendering raster images is
    accomplished via an operation known as bit-block
    transfer or bitwise block transfer.
  • Regardless the abbreviation is BITBLT.
  • Usually pronounced bit blit. Sometimes blit.
    Also blitting, etc. Something that does this is
    a blitter.
  • BITBLT can be done very efficiently in hardware.
  • This fact figured prominently in the early days
    of mass-market GUI machines.
  • E.g., the Commodore Amiga had much faster
    graphics than the original Apple Macintosh,
    largely because it had a specialized BITBLT chip.
  • Read about BITBLT in section 7.3 of the blue book.

8
Images in OpenGLIntroduction Raster Position
  • Now we look at raster-image handling in OpenGL.
  • Primary topic the three image transfer commands
    glDrawPixels, glReadPixels, glCopyPixels.
  • OpenGL draws images in the frame buffer at the
    raster position.
  • We saw this when we discussed GLUT bitmap fonts.
  • Set the raster position with glRasterPos.
  • The raster position goes through the
    vertex-operations portion of the geometry
    pipeline.
  • It is transformed by the model/view, projection,
    and viewport transformations.
  • It is clipped if outside the viewport, no image
    is drawn.
  • Images do not pass through the geometry pipeline.
  • So you cannot rotate them with glRotate, and you
    cannot scale them with glScale.
  • But you can move them with glTranslate, right?
  • However, we can scale and flip images. More on
    this later.

9
Images in OpenGLImage Transfer Commands
  • Function glDrawPixels.
  • Transfers a pixmap from an array to the frame
    buffer.
  • Draws at the current raster position.
  • Does not change the raster position.
  • Function glReadPixels.
  • Transfers a pixmap from a specified position in
    the frame buffer to an array.
  • Do not use the raster position.
  • Function glCopyPixels.
  • Transfers a pixmap from a specified position in
    the frame buffer to the frame buffer.
  • Draws at the current raster position.
  • Does not change the raster position.

10
Images in OpenGLFunction glDrawPixels 1/3
  • Path through the pipeline glDrawPixels.

VertexOperations
FrameBuffer
VertexData
Vertex
Fragments
Vertex
Rasterization
FragmentOperations
Fragment
Fragment
Pixmap
Pixmap
PixelOperations
PixelData
Pixmap
Pixmap
11
Images in OpenGLFunction glDrawPixels 2/3
  • Function glDrawPixels reads an image from an
    array and renders it at the raster position.
  • Five parameters
  • Width Image width in pixels. Integer.
  • Height Image height, in pixels. Integer.
  • Format What data the image holds.
  • Use GL_RGB if you are giving R, G, B data. If you
    add a 4th component (A), make this GL_RGBA.
  • Type Data type in image array.
  • Use GL_UNSIGNED_BYTE for an array of GLubytes.
  • If you feel you need to use some other value
    here, I suggest you sit down until the feeling
    goes away.
  • Pixels Pointer to the array.

12
Images in OpenGLFunction glDrawPixels 3/3
  • So, if your image array looks like this
  • GLubyte img_rgbimg_heightimg_width3
  • Then your glDrawPixels call looks like this
  • glDrawPixels(img_width, img_height,
  • GL_RGB, GL_UNSIGNED_BYTE, img_rgb)
  • Notes
  • Height before width in array subscripts. Width
    first everywhere else.
  • Array data starts at the bottom of the image.
    Image files are stored starting at the top. But
    we can flip an image using glPixelZoom.

13
Images in OpenGLFunction glReadPixels 1/2
  • Path through the pipeline glReadPixels.

VertexOperations
FrameBuffer
VertexData
Vertex
Fragments
Vertex
Rasterization
FragmentOperations
Fragment
Fragment
Pixmap
Pixmap
PixelOperations
PixelData
Pixmap
Pixmap
14
Images in OpenGLFunction glReadPixels 2/2
  • Function glReadPixels reads an image from the
    frame buffer and places it in an array.
  • Seven parameters
  • x, y The pixel coordinates of the pixel at the
    lower-left corner of the image to be read.
    Integers. (0,0) is the pixel at the lower-left
    corner of the frame buffer.
  • The last five parameters are the same as those
    for glDrawPixels.
  • This function does not use the raster position.

15
Images in OpenGLFunction glCopyPixels 1/2
  • Path through the pipeline glCopyPixels.

VertexOperations
FrameBuffer
VertexData
Vertex
Fragments
Vertex
Rasterization
FragmentOperations
Fragment
Fragment
Pixmap
Pixmap
PixelOperations
PixelData
Pixmap
Pixmap
16
Images in OpenGLFunction glCopyPixels 2/2
  • Function glCopyPixels reads an image from the
    frame buffer and renders it at the raster
    position.
  • Five parameters
  • x, y Lower-left corner of pixel rectangle to
    read. Same as in glReadPixels.
  • Width, Height Size of pixel rectangle to read
    render. Same as in glDrawPixels glReadPixels.
  • Type The kind of data to copy. Use GL_COLOR. Not
    the same as in glDrawPixels glReadPixels.
  • Depth and stencil data can also be copied. See CS
    481.
  • Rendering is done at the raster position. What to
    read is specified using pixel coordinates.

17
Images in OpenGLPixel Storage Details
  • OpenGL supports gobs oodles of image array
    formats.
  • As usual, you can ignore most of the storage
    options.
  • One option has a default value that may be
    unexpected.
  • Some processors access data faster if it is
    stored at an even address (or one divisible by 4,
    etc.).
  • OpenGLs unpack alignment specifies the alignment
    requirements for the beginning of each row of a
    pixmap.
  • For example, if the unpack alignment is 2, the
    first pixel of each row will be read from an
    address divisible by 2. So if your image width is
    not even
  • The unpack alignment is 1, 2, 4 (default), or 8.
  • For a normal C/C array, do (in your init
    function?)glPixelStorei(GL_UNPACK_ALIGNMENT,
    1)
  • In short if you use images, do the above
    command.
  • Later, you might change that 1, in order to
    improve speed.

18
Images in OpenGLZooming Flipping 1/2
  • The generation of fragments during rasterization
    of pixmaps is controlled by glPixelZoom.
  • Thus, glPixelZoom affects
  • Functions glDrawPixels, glCopyPixels.
  • It does not affect
  • Functions glReadPixels, glRasterPos, glVertex,
    etc.
  • Two parameters
  • Xfactor Horizontal zoom factor. Floating point.
  • Yfactor Vertical zoom factor. Floating point.

19
Images in OpenGLZooming Flipping 2/2
  • Effects
  • If both factors are 1.0 (default), then one
    fragment is generated for each pixel.
  • Factors work like glScale. Numbers larger than
    1.0 increase the number of fragments generated
    for each pixel.
  • Doing glPixelZoom(2., 1.) scales an image by 2
    horizontally.
  • Negative factors flip the image.
  • So glPixelZoom(1., -1.) does a vertical flip.
  • Notes
  • The pipeline picture tells you what effect
    commands have, but their internal implementation
    may be different.
  • Copying pixels using obvious settings (both
    factors 1.0) may be done in blocks, instead of
    one fragment at a time.
  • So, setting either factor to something other than
    1.0 may substantially slow down pixmap-transfer
    operations.

20
Images in OpenGLPixel Coordinates
  • Pixmap rendering always occurs at the raster
    position. Pixmap reading occurs at a position
    specified in pixel coordinates.
  • Convert between the two, if you want. Or make
    them the same
  • void reshape(int w, int h)
  • glViewport(0, 0, w, h)
  • glMatrixMode(GL_PROJECTION)
  • glLoadIdentity()
  • gluOrtho2D(0, w, 0, h)
  • glMatrixMode(GL_MODELVIEW)
  • glLoadIdentity()

21
Images in OpenGLOther Functions
  • Some other pixmap-related OpenGL calls you want
    want to read about (think full credit ?)
  • Functions glPixelTransfer glPixelMap.
  • These affect the pixel-operations block in the
    image pipeline. Use them to do things like gamma
    correction.
  • Function glBitmap.
  • Like glDrawPixels, but for bitmaps.
  • Contains some features that glDrawPixels does
    not setting the origin for a bitmap to be other
    than the lower-left corner, and moving the raster
    position after drawing. (Why?)
About PowerShow.com