int s2636_device::check_collision( int spriteno1, int spriteno2, const rectangle &cliprect ) { int checksum = 0; UINT8* attr1 = &m_work_ram[sprite_offsets[spriteno1]]; UINT8* attr2 = &m_work_ram[sprite_offsets[spriteno2]]; /* TODO: does not check shadow sprites yet */ m_collision_bitmap->fill(0, cliprect); if ((attr1[0x0a] != 0xff) && (attr2[0x0a] != 0xff)) { int x, y; int x1 = attr1[0x0a] + m_x_offset; int y1 = attr1[0x0c] + m_y_offset; int x2 = attr2[0x0a] + m_x_offset; int y2 = attr2[0x0c] + m_y_offset; int expand1 = (m_work_ram[0xc0] >> (spriteno1 << 1)) & 0x03; int expand2 = (m_work_ram[0xc0] >> (spriteno2 << 1)) & 0x03; /* draw first sprite */ draw_sprite(attr1, 1, y1, x1, expand1, FALSE, *m_collision_bitmap, cliprect); /* get fingerprint */ for (x = x1; x < x1 + SPRITE_WIDTH; x++) for (y = y1; y < y1 + SPRITE_HEIGHT; y++) { if (!cliprect.contains(x, y)) continue; checksum = checksum + m_collision_bitmap->pix16(y, x); } /* black out second sprite */ draw_sprite(attr2, 0, y2, x2, expand2, FALSE, *m_collision_bitmap, cliprect); /* remove fingerprint */ for (x = x1; x < x1 + SPRITE_WIDTH; x++) for (y = y1; y < y1 + SPRITE_HEIGHT; y++) { if (!cliprect.contains(x, y)) continue; checksum = checksum - m_collision_bitmap->pix16(y, x); } }
UINT32 magicard_state::screen_update_magicard(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { magicard_state *state = machine().driver_data<magicard_state>(); int x,y; UINT32 count; bitmap.fill(get_black_pen(machine()), cliprect); //TODO if(!(SCC_DE_VREG)) //display enable return 0; count = ((SCC_VSR_VREG)/2); if(SCC_FG_VREG) //4bpp gfx { for(y=0;y<300;y++) { for(x=0;x<84;x++) { UINT32 color; color = ((m_magicram[count]) & 0x000f)>>0; if(cliprect.contains((x*4)+3, y)) bitmap.pix32(y, (x*4)+3) = machine().pens[color]; color = ((m_magicram[count]) & 0x00f0)>>4; if(cliprect.contains((x*4)+2, y)) bitmap.pix32(y, (x*4)+2) = machine().pens[color]; color = ((m_magicram[count]) & 0x0f00)>>8; if(cliprect.contains((x*4)+1, y)) bitmap.pix32(y, (x*4)+1) = machine().pens[color]; color = ((m_magicram[count]) & 0xf000)>>12; if(cliprect.contains((x*4)+0, y)) bitmap.pix32(y, (x*4)+0) = machine().pens[color]; count++; } } } else //8bpp gfx { for(y=0;y<300;y++)
uint32_t invqix_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y; // this means freeze or blank or something if (m_vctl == 0x100) { return 0; } if (m_vctl == 0x0000) { for(y=0;y<256;y++) { for(x=0;x<256;x++) { uint8_t r,g,b; int pen_data; pen_data = (m_vram[(x+y*256)]); b = (pen_data & 0x001f); g = (pen_data & 0x03e0) >> 5; r = (pen_data & 0x7c00) >> 10; r = (r << 3) | (r & 0x7); g = (g << 3) | (g & 0x7); b = (b << 3) | (b & 0x7); if(cliprect.contains(x, y)) bitmap.pix32(y, x) = r << 16 | g << 8 | b; } } } else if (m_vctl == 0x0001) // flip
UINT32 jantotsu_state::screen_update_jantotsu(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x, y, i; int count = 0; UINT8 pen_i; if(!m_display_on) return 0; for (y = 0; y < 256; y++) { for (x = 0; x < 256; x += 8) { UINT8 color; for (i = 0; i < 8; i++) { color = m_col_bank; for(pen_i = 0;pen_i<4;pen_i++) color |= (((m_bitmap[count + pen_i*0x2000]) >> (7 - i)) & 1) << pen_i; if (cliprect.contains(x + i, y)) bitmap.pix32(y, x + i) = machine().pens[color]; } count++; } } return 0; }
UINT32 gunpey_state::screen_update_gunpey(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { UINT16 *blit_buffer = m_blit_buffer; int x,y; int count; count = 0; for(y=0;y<512;y++) { for(x=0;x<512;x++) { UINT32 color; int r,g,b; color = (blit_buffer[count] & 0xffff); b = (color & 0x001f) << 3; g = (color & 0x03e0) >> 2; r = (color & 0x7c00) >> 7; if(cliprect.contains(x, y)) bitmap.pix32(y, x) = b | (g<<8) | (r<<16); count++; } } return 0; }
uint32_t hd44102_device::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { for (int y = 0; y < 50; y++) { int z = m_page << 3; for (int x = 0; x < 32; x++) { uint8_t data = m_ram[z / 8][y]; int sy = m_sy + z; int sx = m_sx + y; if (cliprect.contains(sx, sy)) { int color = (m_status & STATUS_DISPLAY_OFF) ? 0 : BIT(data, z % 8); bitmap.pix16(sy, sx) = color; } z++; z %= 32; } } return 0; }
UINT32 lbeach_state::screen_update_lbeach(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { // draw bg layer (road) m_bg_tilemap->set_scrolly(0, *m_scroll_y); m_bg_tilemap->draw(screen, bitmap, cliprect, 0, 0); // check collision int sprite_code = *m_sprite_code & 0xf; int sprite_x = *m_sprite_x * 2 - 4; int sprite_y = 160; m_colmap_car.fill(0, cliprect); m_gfxdecode->gfx(2)->transpen(m_palette,m_colmap_car,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0); bitmap_ind16 &fg_bitmap = m_fg_tilemap->pixmap(); m_collision_bg_car = 0; m_collision_fg_car = 0; for (int y = sprite_y; y < (sprite_y + 16); y++) { for (int x = sprite_x; x < (sprite_x + 16) && cliprect.contains(x, y); x++) { m_collision_bg_car |= (bitmap.pix16(y, x) & m_colmap_car.pix16(y, x) & 1); m_collision_fg_car |= (fg_bitmap.pix16(y, x) & m_colmap_car.pix16(y, x) & 1); } } // draw fg layer (tiles) m_fg_tilemap->draw(screen, bitmap, cliprect, 0, 0); // draw player car m_gfxdecode->gfx(2)->transpen(m_palette,bitmap,cliprect, sprite_code, 0, 0, 0, sprite_x, sprite_y, 0); return 0; }
UINT32 prestige_state::screen_update(int bpp, screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { int width = m_lcdc.fb_width + m_lcdc.lcd_w + 1; for (int y = 0; y <= m_lcdc.lcd_h; y++) { int line_start; if (y <= m_lcdc.split_pos) line_start = m_lcdc.addr1 + y * width; else line_start = m_lcdc.addr2 + (y - m_lcdc.split_pos - 1) * width; for (int sx = 0; sx <= m_lcdc.lcd_w; sx++) { UINT8 data = m_vram[(line_start + sx) & 0x1fff]; for (int x = 0; x < 8 / bpp; x++) { int pix = 0; for (int b=0; b<bpp; b++) pix |= BIT(data, 7 - b) << b; if (cliprect.contains(sx * 8 / bpp + x, y)) bitmap.pix16(y, sx * 8 / bpp + x) = pix; data <<= bpp; } } } return 0; }
UINT32 taitowlf_state::screen_update_taitowlf(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y,count; bitmap.fill(m_palette->black_pen(), cliprect); count = (0); for(y=0;y<256;y++) { for(x=0;x<512;x++) { UINT32 color; color = (m_bootscreen_rom[count] & 0xff); if(cliprect.contains(x+0, y)) bitmap.pix32(y, x+0) = m_palette->pen(color); count++; } } return 0; }
static void draw_stars(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int flip) { bosco_state *state = machine.driver_data<bosco_state>(); if (1) { int star_cntr; int set_a, set_b; /* two sets of stars controlled by these bits */ set_a = (state->m_bosco_starblink[0] & 1); set_b = (state->m_bosco_starblink[1] & 1) | 2; for (star_cntr = 0;star_cntr < MAX_STARS;star_cntr++) { int x,y; if ( (set_a == star_seed_tab[star_cntr].set) || ( set_b == star_seed_tab[star_cntr].set) ) { x = (star_seed_tab[star_cntr].x + state->m_stars_scrollx) % 256; y = (star_seed_tab[star_cntr].y + state->m_stars_scrolly) % 256; /* dont draw the stars that are off the screen */ if ( x < 224 ) { if (flip) x += 20*8; if (cliprect.contains(x, y)) bitmap.pix16(y, x) = STARS_COLOR_BASE + star_seed_tab[star_cntr].col; } } } } }
void nitedrvr_state::draw_box(bitmap_ind16 &bitmap, const rectangle &cliprect, int bx, int by, int ex, int ey) { for (int y = by; y < ey; y++) { for (int x = bx; x < ex; x++) if (cliprect.contains(x, y)) bitmap.pix16(y, x) = 1; } }
void gpworld_state::draw_pixel(bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip) { if (flip) { x = bitmap.width() - x - 1; y = bitmap.height() - y - 1; } if (cliprect.contains(x, y)) bitmap.pix32(y, x) = m_palette->pen(color); }
INLINE void draw_pixel(bitmap_ind16 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip) { if (flip) { x = bitmap.width() - x - 1; y = bitmap.height() - y - 1; } if (cliprect.contains(x, y)) bitmap.pix16(y, x) = color; }
INLINE void draw_pixel(running_machine &machine, bitmap_rgb32 &bitmap,const rectangle &cliprect,int x,int y,int color,int flip) { if (flip) { x = bitmap.width() - x - 1; y = bitmap.height() - y - 1; } if (cliprect.contains(x, y)) bitmap.pix32(y, x) = machine.pens[color]; }
int query(node *nd, rectangle r, rectangle qr) { if (r.isBad()) return -INF; if (r.intersects(qr)) return -INF; if (qr.contains(r)) return nd->high; int q1 = query(nd->children[0], r.getLU(), qr); int q2 = query(nd->children[1], r.getRU(), qr); int q3 = query(nd->children[2], r.getLB(), qr); int q4 = query(nd->children[3], r.getRB(), qr); return max(max(q1, q2), max(q3, q4)); }
UINT32 bingor_state::screen_update_bingor(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y,count; bitmap.fill(get_black_pen(machine()), cliprect); count = (0x2000/2); for(y=0;y<256;y++) { for(x=0;x<286;x+=4) { UINT32 color; color = (m_blit_ram[count] & 0xf000)>>12; if(cliprect.contains(x+3, y)) bitmap.pix32(y, x+3) = machine().pens[color]; color = (m_blit_ram[count] & 0x0f00)>>8; if(cliprect.contains(x+2, y)) bitmap.pix32(y, x+2) = machine().pens[color]; color = (m_blit_ram[count] & 0x00f0)>>4; if(cliprect.contains(x+1, y)) bitmap.pix32(y, x+1) = machine().pens[color]; color = (m_blit_ram[count] & 0x000f)>>0; if(cliprect.contains(x+0, y)) bitmap.pix32(y, x+0) = machine().pens[color]; count++; } } return 0; }
static void theend_draw_bullets(running_machine &machine, bitmap_ind16 &bitmap, const rectangle &cliprect, int offs, int x, int y) { int i; /* same as Galaxian, but all bullets are yellow */ for (i = 0; i < 4; i++) { x--; if (cliprect.contains(x, y)) bitmap.pix16(y, x) = BULLETS_COLOR_BASE; } }
uint32_t progolf_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { int count,color,x,y,xi,yi; { int scroll = (m_scrollx_lo | ((m_scrollx_hi & 0x03) << 8)); count = 0; for(x=0;x<128;x++) { for(y=0;y<32;y++) { int tile = m_videoram[count]; m_gfxdecode->gfx(0)->opaque(bitmap,cliprect,tile,1,0,0,(256-x*8)+scroll,y*8); /* wrap-around */ m_gfxdecode->gfx(0)->opaque(bitmap,cliprect,tile,1,0,0,(256-x*8)+scroll-1024,y*8); count++; } } } /* framebuffer is 8x8 chars arranged like a bitmap + a register that controls the pen handling. */ { count = 0; for(y=0;y<256;y+=8) { for(x=0;x<256;x+=8) { for (yi=0;yi<8;yi++) { for (xi=0;xi<8;xi++) { color = m_fg_fb[(xi+yi*8)+count*0x40]; if(color != 0 && cliprect.contains(x+yi, 256-y+xi)) bitmap.pix16(x+yi, 256-y+xi) = m_palette->pen((color & 0x7)); } } count++; } } } return 0; }
uint32_t kontest_state::screen_update( screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect ) { int x,y; int xi,yi; uint16_t tile; uint8_t attr; for(y=0;y<32;y++) { for(x=0;x<64;x++) { tile = m_ram[(x+y*64)|0x800]; attr = m_ram[(x+((y >> 1)*64))|0x000] & 7; tile *= 0x10; tile += 0x1000; for(yi=0;yi<8;yi++) { for(xi=0;xi<8;xi++) { uint8_t color,pen[2]; uint8_t x_step; int res_x,res_y; x_step = xi >> 2; pen[0] = m_ram[(x_step+yi*2)|(tile)]; pen[0] >>= 3-((xi & 3)); pen[0] &= 1; pen[1] = m_ram[(x_step+yi*2)|(tile)]; pen[1] >>= 7-((xi & 3)); pen[1] &= 1; color = pen[0]; color|= pen[1]<<1; res_x = x*8+xi-256; res_y = y*8+yi; if (cliprect.contains(res_x, res_y)) bitmap.pix32(res_y, res_x) = m_palette->pen(color|attr*4); } } } } return 0; }
void update(node *nd, rectangle r, int ur, int uc, int v) { if (r.isBad()) return; if (r.isCell() && r.contains(ur, uc)) nd->high = v; else { if (r.getLU().contains(ur, uc)) update(nd->children[0], r.getLU(), ur, uc, v); else if (r.getRU().contains(ur, uc)) update(nd->children[1], r.getRU(), ur, uc, v); else if (r.getLB().contains(ur, uc)) update(nd->children[2], r.getLB(), ur, uc, v); else if (r.getRB().contains(ur, uc)) update(nd->children[3], r.getRB(), ur, uc, v); pushUp(nd); } }
static void draw_sprite( UINT8 *gfx, int color, int y, int x, int expand, int or_mode, bitmap_ind16 &bitmap, const rectangle &cliprect ) { int sy; /* for each row */ for (sy = 0; sy < SPRITE_HEIGHT; sy++) { int sx; /* for each pixel on the row */ for (sx = 0; sx < SPRITE_WIDTH; sx++) { int ey; /* each pixel can be expanded */ for (ey = 0; ey <= expand; ey++) { int ex; for (ex = 0; ex <= expand; ex++) { /* compute effective destination pixel */ int ty = y + sy * (expand + 1) + ey; int tx = x + sx * (expand + 1) + ex; /* get out if outside the drawing region */ if (!cliprect.contains(tx, ty)) continue; /* get out if current image bit is transparent */ if (((gfx[sy] << sx) & 0x80) == 0x00) continue; if (or_mode) bitmap.pix16(ty, tx) = 0x08 | bitmap.pix16(ty, tx) | color; else bitmap.pix16(ty, tx) = 0x08 | color; } } } } }
int gl3000s_sed1520_screen_update(device_t &device, bitmap_ind16 &bitmap, const rectangle &cliprect, UINT8 *vram, int start_line, int adc, int start_x) { for (int y=0; y<2; y++) { int row_pos = 0; for (int x=0; x<61; x++) { int addr = (y + (start_line >> 3)) * 80 + row_pos; for (int yi=0; yi<8; yi++) { int px = start_x - (adc ? (80 - x) : x); int py = 8 + y*8 + yi; if (cliprect.contains(px, py)) bitmap.pix16(py, px) = (vram[addr % 0x140] >> yi) & 1; } row_pos++; } } return 0; }
UINT32 flipjack_state::screen_update_flipjack(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y,count; bitmap.fill(get_black_pen(machine()), cliprect); // draw playfield if (m_layer & 2) { const UINT8 *blit_data = memregion("gfx2")->base(); count = 0; for(y=0;y<192;y++) { for(x=0;x<256;x+=8) { UINT32 pen_r,pen_g,pen_b,color; int xi; pen_r = (blit_data[count] & 0xff)>>0; pen_g = (blit_data[count+0x2000] & 0xff)>>0; pen_b = (blit_data[count+0x4000] & 0xff)>>0; for(xi=0;xi<8;xi++) { if(cliprect.contains(x+xi, y)) { color = ((pen_r >> (7-xi)) & 1)<<0; color|= ((pen_g >> (7-xi)) & 1)<<1; color|= ((pen_b >> (7-xi)) & 1)<<2; bitmap.pix32(y, x+xi) = machine().pens[color+0x80]; } } count++; } } }
UINT32 flyball_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { int pitcherx = m_pitcher_horz; int pitchery = m_pitcher_vert - 31; int ballx = m_ball_horz - 1; int bally = m_ball_vert - 17; m_tmap->mark_all_dirty(); /* draw playfield */ m_tmap->draw(screen, bitmap, cliprect, 0, 0); /* draw pitcher */ m_gfxdecode->m_gfx[1]->transpen(bitmap,cliprect, m_pitcher_pic ^ 0xf, 0, 1, 0, pitcherx, pitchery, 1); /* draw ball */ for (int y = bally; y < bally + 2; y++) for (int x = ballx; x < ballx + 2; x++) if (cliprect.contains(x, y)) bitmap.pix16(y, x) = 1; return 0; }
UINT32 isa8_cga_tetriskr_device::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y; int yi; const UINT8 *bg_rom = memregion("gfx2")->base(); //popmessage("%04x",m_start_offs); bitmap.fill(rgb_t::black, cliprect); for(y=0;y<200/8;y++) { for(yi=0;yi<8;yi++) { for(x=0;x<320/8;x++) { UINT8 color; int xi,pen_i; for(xi=0;xi<8;xi++) { color = 0; /* TODO: first byte seems bogus? */ for(pen_i = 0;pen_i<4;pen_i++) color |= ((bg_rom[y*320/8+x+(pen_i*0x20000)+yi*0x400+m_bg_bank*0x2000+1] >> (7-xi)) & 1) << pen_i; if(cliprect.contains(x*8+xi, y*8+yi)) bitmap.pix32(y*8+yi, x*8+xi) = m_palette->pen(color); } } } } isa8_cga_device::screen_update(screen, bitmap, cliprect); return 0; }
UINT32 aristmk6_state::screen_update_aristmk6(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int x,y,count; const UINT8 *blit_ram = memregion("maincpu")->base(); if(machine().input().code_pressed(KEYCODE_Z)) m_test_x++; if(machine().input().code_pressed(KEYCODE_X)) m_test_x--; if(machine().input().code_pressed(KEYCODE_A)) m_test_y++; if(machine().input().code_pressed(KEYCODE_S)) m_test_y--; if(machine().input().code_pressed(KEYCODE_Q)) m_start_offs+=0x2000; if(machine().input().code_pressed(KEYCODE_W)) m_start_offs-=0x2000; if(machine().input().code_pressed(KEYCODE_E)) m_start_offs++; if(machine().input().code_pressed(KEYCODE_R)) m_start_offs--; if(machine().input().code_pressed_once(KEYCODE_L)) m_type^=1; popmessage("%d %d %04x %d",m_test_x,m_test_y,m_start_offs,m_type); bitmap.fill(get_black_pen(machine()), cliprect); count = (m_start_offs); for(y=0;y<m_test_y;y++) { for(x=0;x<m_test_x;x++) { if(m_type) { UINT16 vram; int r,g,b; vram = blit_ram[count+0] | blit_ram[count+1]<<8; r = (vram & 0x001f)>>0; g = (vram & 0x07e0)>>5; b = (vram & 0xf800)>>11; r = (r << 3) | (r & 0x7); g = (g << 2) | (g & 3); b = (b << 3) | (b & 0x7); if(cliprect.contains(x, y)) bitmap.pix32(y, x) = r | g<<8 | b<<16; count+=2; } else { UINT8 color; color = blit_ram[count]; if(cliprect.contains(x, y)) bitmap.pix32(y, x) = machine().pens[color]; count++; } } }
/* * Sprite Format * ------------------ * * Word | Bit(s) | Use * -----+-fedcba9876543210-+---------------- * 0 | --------xxxxxxxx | display y start * 0 | xxxxxxxx-------- | display y end * 2 | -------xxxxxxxxx | x position * 2 | ------x--------- | unknown (used in logicpr2, maybe just a bug?) * 2 | xxxxxx---------- | unused? * 4 | ---------xxxxxxx | width * 4 | --------x------- | is this flip y like in System 16? * 4 | -------x-------- | flip x * 4 | xxxxxxx--------- | unused? * 6 | xxxxxxxxxxxxxxxx | ROM address low bits * 8 | ----------xxxxxx | color * 8 | --------xx------ | priority * 8 | ---xxxxx-------- | ROM address high bits * 8 | xxx------------- | unused? (extra address bits for larger ROMs?) * a | ---------------- | zoomx like in System 16? * c | ---------------- | zoomy like in System 16? * e | ---------------- | */ void deniam_state::draw_sprites( bitmap_ind16 &bitmap, const rectangle &cliprect ) { int offs; UINT8 *gfx = memregion("gfx2")->base(); for (offs = m_spriteram.bytes() / 2 - 8; offs >= 0; offs -= 8) { int sx, starty, endy, x, y, start, color, width, flipx, primask; UINT8 *rom = gfx; sx = (m_spriteram[offs + 1] & 0x01ff) + 16 * 8 - 1; if (sx >= 512) sx -= 512; starty = m_spriteram[offs + 0] & 0xff; endy = m_spriteram[offs + 0] >> 8; width = m_spriteram[offs + 2] & 0x007f; flipx = m_spriteram[offs + 2] & 0x0100; if (flipx) sx++; color = 0x40 + (m_spriteram[offs + 4] & 0x3f); primask = 8; switch (m_spriteram[offs + 4] & 0xc0) { case 0x00: primask |= 4 | 2 | 1; break; /* below everything */ case 0x40: primask |= 4 | 2; break; /* below fg and tx */ case 0x80: primask |= 4; break; /* below tx */ case 0xc0: break; /* above everything */ } start = m_spriteram[offs + 3] + ((m_spriteram[offs + 4] & 0x1f00) << 8); rom += 2 * start; for (y = starty + 1; y <= endy; y++) { int drawing = 0; int i = 0; rom += 2 * width; /* note that the first line is skipped */ x = 0; while (i < 512) /* safety check */ { if (flipx) { if ((rom[i] & 0x0f) == 0x0f) { if (!drawing) drawing = 1; else break; } else { if (rom[i] & 0x0f) { if (cliprect.contains(sx + x, y)) { if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0) bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f); machine().priority_bitmap.pix8(y, sx + x) = 8; } } x++; } if ((rom[i] & 0xf0) == 0xf0) { if (!drawing) drawing = 1; else break; } else { if (rom[i] & 0xf0) { if (cliprect.contains(sx + x, y)) { if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0) bitmap.pix16(y, sx + x) = color * 16+(rom[i] >> 4); machine().priority_bitmap.pix8(y, sx + x) = 8; } } x++; } i--; } else { if ((rom[i] & 0xf0) == 0xf0) { if (!drawing) drawing = 1; else break; } else { if (rom[i] & 0xf0) { if (cliprect.contains(sx + x, y)) { if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0) bitmap.pix16(y, sx + x) = color * 16 + (rom[i] >> 4); machine().priority_bitmap.pix8(y, sx + x) = 8; } } x++; } if ((rom[i] & 0x0f) == 0x0f) { if (!drawing) drawing = 1; else break; } else { if (rom[i] & 0x0f) { if (cliprect.contains(sx + x, y)) { if ((machine().priority_bitmap.pix8(y, sx + x) & primask) == 0) bitmap.pix16(y, sx + x) = color * 16 + (rom[i] & 0x0f); machine().priority_bitmap.pix8(y, sx + x) = 8; } } x++; } i++; } } } }
int main(int argc, char** argv) { try { command_line_parser parser; parser.add_option("h","Displays this information."); parser.add_option("v","Display version."); parser.set_group_name("Creating XML files"); parser.add_option("c","Create an XML file named <arg> listing a set of images.",1); parser.add_option("r","Search directories recursively for images."); parser.add_option("convert","Convert foreign image Annotations from <arg> format to the imglab format. " "Supported formats: pascal-xml, pascal-v1, idl.",1); parser.set_group_name("Viewing XML files"); parser.add_option("tile","Chip out all the objects and save them as one big image called <arg>.",1); parser.add_option("size","When using --tile or --cluster, make each extracted object contain " "about <arg> pixels (default 8000).",1); parser.add_option("l","List all the labels in the given XML file."); parser.add_option("stats","List detailed statistics on the object labels in the given XML file."); parser.set_group_name("Editing/Transforming XML files"); parser.add_option("rename", "Rename all labels of <arg1> to <arg2>.",2); parser.add_option("parts","The display will allow image parts to be labeled. The set of allowable parts " "is defined by <arg> which should be a space separated list of parts.",1); parser.add_option("rmdupes","Remove duplicate images from the dataset. This is done by comparing " "the md5 hash of each image file and removing duplicate images. " ); parser.add_option("rmdiff","Set the ignored flag to true for boxes marked as difficult."); parser.add_option("rmtrunc","Set the ignored flag to true for boxes that are partially outside the image."); parser.add_option("shuffle","Randomly shuffle the order of the images listed in file <arg>."); parser.add_option("seed", "When using --shuffle, set the random seed to the string <arg>.",1); parser.add_option("split", "Split the contents of an XML file into two separate files. One containing the " "images with objects labeled <arg> and another file with all the other images. Additionally, the file " "containing the <arg> labeled objects will not contain any other labels other than <arg>. " "That is, the images in the first file are stripped of all labels other than the <arg> labels.",1); parser.add_option("add", "Add the image metadata from <arg1> into <arg2>. If any of the image " "tags are in both files then the ones in <arg2> are deleted and replaced with the " "image tags from <arg1>. The results are saved into merged.xml and neither <arg1> or " "<arg2> files are modified.",2); parser.add_option("flip", "Read an XML image dataset from the <arg> XML file and output a left-right flipped " "version of the dataset and an accompanying flipped XML file named flipped_<arg>.",1); parser.add_option("rotate", "Read an XML image dataset and output a copy that is rotated counter clockwise by <arg> degrees. " "The output is saved to an XML file prefixed with rotated_<arg>.",1); parser.add_option("cluster", "Cluster all the objects in an XML file into <arg> different clusters and save " "the results as cluster_###.xml and cluster_###.jpg files.",1); parser.add_option("resample", "Crop out images that are centered on each object in the dataset. Make the " "crops so that the objects have <arg> pixels in them. The output is a new XML dataset.",1); parser.add_option("extract-chips", "Crops out images with tight bounding boxes around each object. Also crops out " "many background chips. All these image chips are serialized into one big data file. The chips will contain <arg> pixels each",1); parser.parse(argc, argv); const char* singles[] = {"h","c","r","l","convert","parts","rmdiff", "rmtrunc", "rmdupes", "seed", "shuffle", "split", "add", "flip", "rotate", "tile", "size", "cluster", "resample", "extract-chips"}; parser.check_one_time_options(singles); const char* c_sub_ops[] = {"r", "convert"}; parser.check_sub_options("c", c_sub_ops); parser.check_sub_option("shuffle", "seed"); const char* size_parent_ops[] = {"tile", "cluster"}; parser.check_sub_options(size_parent_ops, "size"); parser.check_incompatible_options("c", "l"); parser.check_incompatible_options("c", "rmdiff"); parser.check_incompatible_options("c", "rmdupes"); parser.check_incompatible_options("c", "rmtrunc"); parser.check_incompatible_options("c", "add"); parser.check_incompatible_options("c", "flip"); parser.check_incompatible_options("c", "rotate"); parser.check_incompatible_options("c", "rename"); parser.check_incompatible_options("c", "parts"); parser.check_incompatible_options("c", "tile"); parser.check_incompatible_options("c", "cluster"); parser.check_incompatible_options("c", "resample"); parser.check_incompatible_options("c", "extract-chips"); parser.check_incompatible_options("l", "rename"); parser.check_incompatible_options("l", "add"); parser.check_incompatible_options("l", "parts"); parser.check_incompatible_options("l", "flip"); parser.check_incompatible_options("l", "rotate"); parser.check_incompatible_options("add", "flip"); parser.check_incompatible_options("add", "rotate"); parser.check_incompatible_options("add", "tile"); parser.check_incompatible_options("flip", "tile"); parser.check_incompatible_options("rotate", "tile"); parser.check_incompatible_options("cluster", "tile"); parser.check_incompatible_options("resample", "tile"); parser.check_incompatible_options("extract-chips", "tile"); parser.check_incompatible_options("flip", "cluster"); parser.check_incompatible_options("rotate", "cluster"); parser.check_incompatible_options("add", "cluster"); parser.check_incompatible_options("flip", "resample"); parser.check_incompatible_options("rotate", "resample"); parser.check_incompatible_options("add", "resample"); parser.check_incompatible_options("flip", "extract-chips"); parser.check_incompatible_options("rotate", "extract-chips"); parser.check_incompatible_options("add", "extract-chips"); parser.check_incompatible_options("shuffle", "tile"); parser.check_incompatible_options("convert", "l"); parser.check_incompatible_options("convert", "rename"); parser.check_incompatible_options("convert", "parts"); parser.check_incompatible_options("convert", "cluster"); parser.check_incompatible_options("convert", "resample"); parser.check_incompatible_options("convert", "extract-chips"); parser.check_incompatible_options("rmdiff", "rename"); parser.check_incompatible_options("rmdupes", "rename"); parser.check_incompatible_options("rmtrunc", "rename"); const char* convert_args[] = {"pascal-xml","pascal-v1","idl"}; parser.check_option_arg_range("convert", convert_args); parser.check_option_arg_range("cluster", 2, 999); parser.check_option_arg_range("rotate", -360, 360); parser.check_option_arg_range("size", 10*10, 1000*1000); parser.check_option_arg_range("resample", 4, 1000*1000); parser.check_option_arg_range("extract-chips", 4, 1000*1000); if (parser.option("h")) { cout << "Usage: imglab [options] <image files/directories or XML file>\n"; parser.print_options(cout); cout << endl << endl; return EXIT_SUCCESS; } if (parser.option("add")) { merge_metadata_files(parser); return EXIT_SUCCESS; } if (parser.option("flip")) { flip_dataset(parser); return EXIT_SUCCESS; } if (parser.option("rotate")) { rotate_dataset(parser); return EXIT_SUCCESS; } if (parser.option("v")) { cout << "imglab v" << VERSION << "\nCompiled: " << __TIME__ << " " << __DATE__ << "\nWritten by Davis King\n"; cout << "Check for updates at http://dlib.net\n\n"; return EXIT_SUCCESS; } if (parser.option("tile")) { return tile_dataset(parser); } if (parser.option("cluster")) { return cluster_dataset(parser); } if (parser.option("resample")) { return resample_dataset(parser); } if (parser.option("extract-chips")) { return extract_chips(parser); } if (parser.option("c")) { if (parser.option("convert")) { if (parser.option("convert").argument() == "pascal-xml") convert_pascal_xml(parser); else if (parser.option("convert").argument() == "pascal-v1") convert_pascal_v1(parser); else if (parser.option("convert").argument() == "idl") convert_idl(parser); } else { create_new_dataset(parser); } return EXIT_SUCCESS; } if (parser.option("rmdiff")) { if (parser.number_of_arguments() != 1) { cerr << "The --rmdiff option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); for (unsigned long i = 0; i < data.images.size(); ++i) { for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j) { if (data.images[i].boxes[j].difficult) data.images[i].boxes[j].ignore = true; } } save_image_dataset_metadata(data, parser[0]); return EXIT_SUCCESS; } if (parser.option("rmdupes")) { if (parser.number_of_arguments() != 1) { cerr << "The --rmdupes option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data, data_out; std::set<std::string> hashes; load_image_dataset_metadata(data, parser[0]); data_out = data; data_out.images.clear(); for (unsigned long i = 0; i < data.images.size(); ++i) { ifstream fin(data.images[i].filename.c_str(), ios::binary); string hash = md5(fin); if (hashes.count(hash) == 0) { hashes.insert(hash); data_out.images.push_back(data.images[i]); } } save_image_dataset_metadata(data_out, parser[0]); return EXIT_SUCCESS; } if (parser.option("rmtrunc")) { if (parser.number_of_arguments() != 1) { cerr << "The --rmtrunc option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); { locally_change_current_dir chdir(get_parent_directory(file(parser[0]))); for (unsigned long i = 0; i < data.images.size(); ++i) { array2d<unsigned char> img; load_image(img, data.images[i].filename); const rectangle area = get_rect(img); for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j) { if (!area.contains(data.images[i].boxes[j].rect)) data.images[i].boxes[j].ignore = true; } } } save_image_dataset_metadata(data, parser[0]); return EXIT_SUCCESS; } if (parser.option("l")) { if (parser.number_of_arguments() != 1) { cerr << "The -l option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); print_all_labels(data); return EXIT_SUCCESS; } if (parser.option("split")) { return split_dataset(parser); } if (parser.option("shuffle")) { if (parser.number_of_arguments() != 1) { cerr << "The -shuffle option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); const string default_seed = cast_to_string(time(0)); const string seed = get_option(parser, "seed", default_seed); dlib::rand rnd(seed); randomize_samples(data.images, rnd); save_image_dataset_metadata(data, parser[0]); return EXIT_SUCCESS; } if (parser.option("stats")) { if (parser.number_of_arguments() != 1) { cerr << "The --stats option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); print_all_label_stats(data); return EXIT_SUCCESS; } if (parser.option("rename")) { if (parser.number_of_arguments() != 1) { cerr << "The --rename option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } dlib::image_dataset_metadata::dataset data; load_image_dataset_metadata(data, parser[0]); for (unsigned long i = 0; i < parser.option("rename").count(); ++i) { rename_labels(data, parser.option("rename").argument(0,i), parser.option("rename").argument(1,i)); } save_image_dataset_metadata(data, parser[0]); return EXIT_SUCCESS; } if (parser.number_of_arguments() == 1) { metadata_editor editor(parser[0]); if (parser.option("parts")) { std::vector<string> parts = split(parser.option("parts").argument()); for (unsigned long i = 0; i < parts.size(); ++i) { editor.add_labelable_part_name(parts[i]); } } editor.wait_until_closed(); } } catch (exception& e) { cerr << e.what() << endl; return EXIT_FAILURE; } }
int resample_dataset(const command_line_parser& parser) { if (parser.number_of_arguments() != 1) { cerr << "The --resample option requires you to give one XML file on the command line." << endl; return EXIT_FAILURE; } const size_t obj_size = get_option(parser,"resample",100*100); const double margin_scale = 2.5; // cropped image will be this times wider than the object. const size_t image_size = obj_size*margin_scale*margin_scale; dlib::image_dataset_metadata::dataset data, resampled_data; resampled_data.comment = data.comment; resampled_data.name = data.name + " RESAMPLED"; load_image_dataset_metadata(data, parser[0]); locally_change_current_dir chdir(get_parent_directory(file(parser[0]))); console_progress_indicator pbar(data.images.size()); for (unsigned long i = 0; i < data.images.size(); ++i) { // don't even bother loading images that don't have objects. if (data.images[i].boxes.size() == 0) continue; pbar.print_status(i); array2d<rgb_pixel> img, chip; load_image(img, data.images[i].filename); // figure out what chips we want to take from this image for (unsigned long j = 0; j < data.images[i].boxes.size(); ++j) { const rectangle rect = data.images[i].boxes[j].rect; if (data.images[i].boxes[j].ignore || !get_rect(img).contains(rect)) continue; const rectangle crop_rect = centered_rect(rect, rect.width()*margin_scale, rect.height()*margin_scale); // skip crops that have a lot of border pixels if (get_rect(img).intersect(crop_rect).area() < crop_rect.area()*0.8) continue; const rectangle_transform tform = get_mapping_to_chip(chip_details(crop_rect, image_size)); extract_image_chip(img, chip_details(crop_rect, image_size), chip); image_dataset_metadata::image dimg; // Now transform the boxes to the crop and also mark them as ignored if they // have already been cropped out or are outside the crop. for (size_t k = 0; k < data.images[i].boxes.size(); ++k) { image_dataset_metadata::box box = data.images[i].boxes[k]; // ignore boxes outside the cropped image if (crop_rect.intersect(box.rect).area() == 0) continue; // mark boxes we include in the crop as ignored. Also mark boxes that // aren't totally within the crop as ignored. if (crop_rect.contains(grow_rect(box.rect,10))) data.images[i].boxes[k].ignore = true; else box.ignore = true; box.rect = tform(box.rect); for (auto&& p : box.parts) p.second = tform.get_tform()(p.second); dimg.boxes.push_back(box); } dimg.filename = data.images[i].filename + "RESAMPLED"+cast_to_string(j)+".jpg"; save_jpeg(chip,dimg.filename, 98); resampled_data.images.push_back(dimg); } } save_image_dataset_metadata(resampled_data, parser[0] + ".RESAMPLED.xml"); return EXIT_SUCCESS; }
UINT32 archimedes_state::screen_update(screen_device &screen, bitmap_rgb32 &bitmap, const rectangle &cliprect) { int xstart,ystart,xend,yend; int res_x,res_y; int xsize,ysize; int calc_dxs = 0,calc_dxe = 0; const UINT8 x_step[4] = { 5, 7, 11, 19 }; /* border color */ bitmap.fill(m_palette->pen(0x10), cliprect); /* define X display area through BPP mode register */ calc_dxs = (m_vidc_regs[VIDC_HDSR]*2)+x_step[m_vidc_bpp_mode & 3]; calc_dxe = (m_vidc_regs[VIDC_HDER]*2)+x_step[m_vidc_bpp_mode & 3]; /* now calculate display clip rectangle start/end areas */ xstart = (calc_dxs)-m_vidc_regs[VIDC_HBSR]; ystart = (m_vidc_regs[VIDC_VDSR])-m_vidc_regs[VIDC_VBSR]; xend = (calc_dxe)+xstart; yend = m_vidc_regs[VIDC_VDER]+ystart; /* disable the screen if display params are invalid */ if(xstart > xend || ystart > yend) return 0; xsize = calc_dxe-calc_dxs; ysize = m_vidc_regs[VIDC_VDER]-m_vidc_regs[VIDC_VDSR]; { int count; int x,y,xi; UINT8 pen; static UINT8 *vram = memregion("vram")->base(); count = (0); switch(m_vidc_bpp_mode) { case 0: //1 bpp { for(y=0;y<ysize;y++) { for(x=0;x<xsize;x+=8) { pen = vram[count]; for(xi=0;xi<8;xi++) { res_x = x+xi+xstart; res_y = (y+ystart)*(m_vidc_interlace+1); if(m_vidc_interlace) { if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend) bitmap.pix32(res_y, res_x) = m_palette->pen((pen>>(xi))&0x1); if (cliprect.contains(res_x, res_y+1) && (res_x) <= xend && (res_y+1) <= yend) bitmap.pix32(res_y+1, res_x) = m_palette->pen((pen>>(xi))&0x1); } else { if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend) bitmap.pix32(res_y, res_x) = m_palette->pen((pen>>(xi))&0x1); } } count++; } } } break; case 3: //8 bpp { for(y=0;y<ysize;y++) { for(x=0;x<xsize;x++) { pen = vram[count]; res_x = x+xstart; res_y = (y+ystart)*(m_vidc_interlace+1); if(m_vidc_interlace) { if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend) bitmap.pix32(res_y, res_x) = m_palette->pen((pen&0xff)+0x100); if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y+1) <= yend) bitmap.pix32(res_y+1, res_x) = m_palette->pen((pen&0xff)+0x100); } else { if (cliprect.contains(res_x, res_y) && (res_x) <= xend && (res_y) <= yend) bitmap.pix32(res_y, res_x) = m_palette->pen((pen&0xff)+0x100); } count++; } } } break; } }