Diff: u8glibARM/u8g_polygon.c

Revision:

2:6cd3b0947188

Parent:

1:0e75de2a5d21

Child:

3:4cd9171ba989

diff -r 0e75de2a5d21 -r 6cd3b0947188 u8glibARM/u8g_polygon.c
--- a/u8glibARM/u8g_polygon.c	Mon Jun 13 02:21:11 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,335 +0,0 @@
-/*
-
-  u8g_polygon.c
-
-  Implementation of a polygon draw algorithm for "convex" polygons. 
- 
-  Universal 8bit Graphics Library
-  
-  Copyright (c) 2013, olikraus@gmail.com
-  All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without modification, 
-  are permitted provided that the following conditions are met:
-
-  * Redistributions of source code must retain the above copyright notice, this list 
-    of conditions and the following disclaimer.
-    
-  * Redistributions in binary form must reproduce the above copyright notice, this 
-    list of conditions and the following disclaimer in the documentation and/or other 
-    materials provided with the distribution.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
-  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
-  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
-  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
-  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
-  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
-  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
-  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
-  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
-  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
-  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
-  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
- 
-  See also:
-  http://www.angelfire.com/linux/myp/ConvexPolRas/ConvexPolRas.html
-  Computer Graphics, Principles and Practice, Foley, van Dam, Feiner, Hughes (pp 92)
-  Michael Abrash's Graphics Programming Black Book, Special Edition (Chapter 38 and 39)
-
-  Optimized for embedded systems
-  - static memory usage only
-  - consistent data types
-  - low flash ROM consumption
-  
-*/
-
-
-#include "u8g.h"
-
-
-
-
-/*===========================================*/
-/* procedures, which should not be inlined (save as much flash ROM as possible */
-
-static uint8_t pge_Next(struct pg_edge_struct *pge) PG_NOINLINE;
-static uint8_t pg_inc(pg_struct *pg, uint8_t i) PG_NOINLINE;
-static uint8_t pg_dec(pg_struct *pg, uint8_t i) PG_NOINLINE;
-static void pg_expand_min_y(pg_struct *pg, pg_word_t min_y, uint8_t pge_idx) PG_NOINLINE;
-static void pg_line_init(pg_struct * const pg, uint8_t pge_index) PG_NOINLINE;
-
-/*===========================================*/
-/* line draw algorithm */
-
-static uint8_t pge_Next(struct pg_edge_struct *pge)
-{
-  if ( pge->current_y >= pge->max_y )
-    return 0;
-  
-  pge->current_x += pge->current_x_offset;
-  pge->error += pge->error_offset;
-  if ( pge->error > 0 )
-  {
-    pge->current_x += pge->x_direction;
-    pge->error -= pge->height;
-  }  
-  
-  pge->current_y++;
-  return 1;
-}
-
-/* assumes y2 > y1 */
-static void pge_Init(struct pg_edge_struct *pge, pg_word_t x1, pg_word_t y1, pg_word_t x2, pg_word_t y2)
-{
-  pg_word_t dx = x2 - x1;
-  pg_word_t width;
-
-  pge->height = y2 - y1;
-  pge->max_y = y2;
-  pge->current_y = y1;
-  pge->current_x = x1;
-
-  if ( dx >= 0 )
-  {
-    pge->x_direction = 1;
-    width = dx;
-    pge->error = 0;
-  }
-  else
-  {
-    pge->x_direction = -1;
-    width = -dx;
-    pge->error = 1 - pge->height;
-  }
-  
-  pge->current_x_offset = dx / pge->height;
-  pge->error_offset = width % pge->height;
-}
-
-/*===========================================*/
-/* convex polygon algorithm */
-
-static uint8_t pg_inc(pg_struct *pg, uint8_t i)
-{
-    i++;
-    if ( i >= pg->cnt )
-      i = 0;
-    return i;
-}
-
-static uint8_t pg_dec(pg_struct *pg, uint8_t i)
-{
-    i--;
-    if ( i >= pg->cnt )
-      i = pg->cnt-1;
-    return i;
-}
-
-static void pg_expand_min_y(pg_struct *pg, pg_word_t min_y, uint8_t pge_idx)
-{
-  uint8_t i = pg->pge[pge_idx].curr_idx;
-  for(;;)
-  {
-    i = pg->pge[pge_idx].next_idx_fn(pg, i);
-    if ( pg->list[i].y != min_y )
-      break;	
-    pg->pge[pge_idx].curr_idx = i;
-  }
-}
-
-static uint8_t pg_prepare(pg_struct *pg)
-{
-  pg_word_t max_y;
-  pg_word_t min_y;
-  uint8_t i;
-
-  /* setup the next index procedures */
-  pg->pge[PG_RIGHT].next_idx_fn = pg_inc;
-  pg->pge[PG_LEFT].next_idx_fn = pg_dec;
-  
-  /* search for highest and lowest point */
-  max_y = pg->list[0].y;
-  min_y = pg->list[0].y;
-  pg->pge[PG_LEFT].curr_idx = 0;
-  for( i = 1; i < pg->cnt; i++ )
-  {
-    if ( max_y < pg->list[i].y )
-    {
-      max_y = pg->list[i].y;
-    }
-    if ( min_y > pg->list[i].y )
-    {
-      pg->pge[PG_LEFT].curr_idx = i;
-      min_y = pg->list[i].y;
-    }
-  }
-
-  /* calculate total number of scan lines */
-  pg->total_scan_line_cnt = max_y;
-  pg->total_scan_line_cnt -= min_y;
-  
-  /* exit if polygon height is zero */
-  if ( pg->total_scan_line_cnt == 0 )
-    return 0;
-  
-  /* if the minimum y side is flat, try to find the lowest and highest x points */
-  pg->pge[PG_RIGHT].curr_idx = pg->pge[PG_LEFT].curr_idx;  
-  pg_expand_min_y(pg, min_y, PG_RIGHT);
-  pg_expand_min_y(pg, min_y, PG_LEFT);
-  
-  /* check if the min side is really flat (depends on the x values) */
-  pg->is_min_y_not_flat = 1;
-  if ( pg->list[pg->pge[PG_LEFT].curr_idx].x != pg->list[pg->pge[PG_RIGHT].curr_idx].x )
-  {
-    pg->is_min_y_not_flat = 0;
-  }
-  else
-  {
-    pg->total_scan_line_cnt--;
-    if ( pg->total_scan_line_cnt == 0 )
-      return 0;
-  }
-
-  return 1;
-}
-
-static void pg_hline(pg_struct *pg, u8g_t *u8g)
-{
-  pg_word_t x1, x2, y;
-  x1 = pg->pge[PG_LEFT].current_x;
-  x2 = pg->pge[PG_RIGHT].current_x;
-  y = pg->pge[PG_RIGHT].current_y;
-  
-  if ( y < 0 )
-    return;
-  if ( y >= u8g_GetHeight(u8g) )
-    return;
-  if ( x1 < x2 )
-  {
-    if ( x2 < 0 )
-      return;
-    if ( x1 >= u8g_GetWidth(u8g) )
-      return;
-    if ( x1 < 0 )
-      x1 = 0;
-    if ( x2 >= u8g_GetWidth(u8g) )
-      x2 = u8g_GetWidth(u8g);
-    u8g_DrawHLine(u8g, x1, y, x2 - x1);
-  }
-  else
-  {
-    if ( x1 < 0 )
-      return;
-    if ( x2 >= u8g_GetWidth(u8g) )
-      return;
-    if ( x2 < 0 )
-      x1 = 0;
-    if ( x1 >= u8g_GetWidth(u8g) )
-      x1 = u8g_GetWidth(u8g);
-    u8g_DrawHLine(u8g, x2, y, x1 - x2);
-  }
-}
-
-static void pg_line_init(pg_struct * pg, uint8_t pge_index)
-{
-  struct pg_edge_struct  *pge = pg->pge+pge_index;
-  uint8_t idx;  
-  pg_word_t x1;
-  pg_word_t y1;
-  pg_word_t x2;
-  pg_word_t y2;
-
-  idx = pge->curr_idx;  
-  y1 = pg->list[idx].y;
-  x1 = pg->list[idx].x;
-  idx = pge->next_idx_fn(pg, idx);
-  y2 = pg->list[idx].y;
-  x2 = pg->list[idx].x; 
-  pge->curr_idx = idx;
-  
-  pge_Init(pge, x1, y1, x2, y2);
-}
-
-static void pg_exec(pg_struct *pg, u8g_t *u8g)
-{
-  pg_word_t i = pg->total_scan_line_cnt;
-
-  /* first line is skipped if the min y line is not flat */
-  pg_line_init(pg, PG_LEFT);		
-  pg_line_init(pg, PG_RIGHT);
-  
-  if ( pg->is_min_y_not_flat != 0 )
-  {
-    pge_Next(&(pg->pge[PG_LEFT])); 
-    pge_Next(&(pg->pge[PG_RIGHT]));
-  }
-
-  do
-  {
-    pg_hline(pg, u8g);
-    while ( pge_Next(&(pg->pge[PG_LEFT])) == 0 )
-    {
-      pg_line_init(pg, PG_LEFT);
-    }
-    while ( pge_Next(&(pg->pge[PG_RIGHT])) == 0 )
-    {
-      pg_line_init(pg, PG_RIGHT);
-    }
-    i--;
-  } while( i > 0 );
-}
-
-/*===========================================*/
-/* API procedures */
-
-void pg_ClearPolygonXY(pg_struct *pg)
-{
-  pg->cnt = 0;
-}
-
-void pg_AddPolygonXY(pg_struct *pg, u8g_t *u8g, int16_t x, int16_t y)
-{
-  if ( pg->cnt < PG_MAX_POINTS )
-  {
-    pg->list[pg->cnt].x = x;
-    pg->list[pg->cnt].y = y;
-    pg->cnt++;
-  }
-}
-
-void pg_DrawPolygon(pg_struct *pg, u8g_t *u8g)
-{
-  if ( pg_prepare(pg) == 0 )
-    return;
-  pg_exec(pg, u8g);
-}
-
-pg_struct u8g_pg;
-
-void u8g_ClearPolygonXY(void)
-{
-  pg_ClearPolygonXY(&u8g_pg);
-}
-
-void u8g_AddPolygonXY(u8g_t *u8g, int16_t x, int16_t y)
-{
-  pg_AddPolygonXY(&u8g_pg, u8g, x, y);
-}
-
-void u8g_DrawPolygon(u8g_t *u8g)
-{
-  pg_DrawPolygon(&u8g_pg, u8g);
-}
-
-void u8g_DrawTriangle(u8g_t *u8g, int16_t x0, int16_t y0, int16_t x1, int16_t y1, int16_t x2, int16_t y2)
-{
-  u8g_ClearPolygonXY();
-  u8g_AddPolygonXY(u8g, x0, y0);
-  u8g_AddPolygonXY(u8g, x1, y1);
-  u8g_AddPolygonXY(u8g, x2, y2);
-  u8g_DrawPolygon(u8g);
-}
-
-