1618 lines
58 KiB
Verilog
Executable File
1618 lines
58 KiB
Verilog
Executable File
//**************************************************************************
|
|
// author: Alexander Bochem
|
|
// date: 07.05.2010
|
|
//**************************************************************************
|
|
//input: RLE encoded pixel data
|
|
//output: blob attributes merged with bounding box criteria
|
|
//
|
|
//description:
|
|
// - read RLE encoded pixel data from input fifo
|
|
// - merge Runs based on bounding box criteria
|
|
// - write Blobs attributes to output fifo
|
|
//**************************************************************************
|
|
//change: 13.05.2010
|
|
// condition checks in state CHECK_PIXEL implemented to merge adjacent
|
|
// runs into BLOB containers
|
|
//
|
|
// 15.05.2010
|
|
// included BLOB_RANGE and CONT_RANGE for adjacency check
|
|
// eliminates multiple detection of BLOBs
|
|
//
|
|
// 26.05.2010
|
|
// extended to detect up to six BLOBs
|
|
//
|
|
// 27.05.2010
|
|
// add average X and Y edge to output for
|
|
// threshold adjustment
|
|
//
|
|
// 29.05.2010
|
|
// include collecting data for center of mass method in RLE merging process
|
|
// change module name to RLE_BlobMerging
|
|
//
|
|
// 31.05.2010
|
|
// include computation for center of mass
|
|
//**************************************************************************
|
|
|
|
`define LSB_X 1'b0
|
|
`define MSB_X 4'b1010
|
|
`define LSB_Y 4'b1011
|
|
`define MSB_Y 5'b10101
|
|
`define LSB_RunLength 5'b10110
|
|
`define MSB_RunLength 5'b11111
|
|
`define LSB_RunSumValues 6'b100000
|
|
`define MSB_RunSumValues 6'b11111
|
|
`define LSB_RunSumXpositions 7'b1000000
|
|
`define MSB_RunSumXpositions 7'b1011111
|
|
`define LSB_RunSumYpositions 7'b1100000
|
|
`define MSB_RunSumYpositions 7'b1111111
|
|
`define LSB_EOFflag 1'b0
|
|
`define MSB_EOFflag 5'b11111
|
|
`define CONT_RANGE 5'b01010
|
|
`define BLOB_RANGE 5'b01010
|
|
|
|
|
|
`define FALSE 1'b0
|
|
`define TRUE 1'b1
|
|
`define INIT 5'b00000
|
|
`define IDLE 5'b00001
|
|
`define CHECK_CONDITIONS 5'b00010
|
|
`define WRITE_FIFO 5'b00011
|
|
`define WAIT_FIFO 5'b00100
|
|
`define COMPUTE_CENTER 5'b00101
|
|
`define VALIDATE_CHECK_ADJACENT_CONTAINER 5'b00110
|
|
`define READ_FIFO 5'b00111
|
|
`define CONFIG_WRITE 5'b01000
|
|
`define WRITE_WAIT 5'b01001
|
|
`define SELECT_EMPTY_CONTAINER 5'b01010
|
|
`define CHECK_ADJACENT_CONTAINTER 5'b01011
|
|
`define CHECK_CONT_ADJACENCY 5'b01100
|
|
`define MERGE_CONTAINER 5'b01101
|
|
`define WRITE_BLOB_0 4'b0000
|
|
`define WRITE_BLOB_1 4'b0001
|
|
`define WRITE_BLOB_2 4'b0010
|
|
`define WRITE_BLOB_3 4'b0011
|
|
`define WRITE_BLOB_4 4'b0100
|
|
`define WRITE_BLOB_5 4'b0101
|
|
`define EOF 32'b00000000000000000000000000000000
|
|
`define MERGE_CONT_1_2 5'b01110
|
|
`define MERGE_CONT_1_3 5'b01111
|
|
`define MERGE_CONT_1_4 5'b10000
|
|
`define MERGE_CONT_1_5 5'b10001
|
|
`define MERGE_CONT_2_3 5'b10010
|
|
`define MERGE_CONT_2_4 5'b10011
|
|
`define MERGE_CONT_2_5 5'b10100
|
|
`define MERGE_CONT_3_4 5'b10101
|
|
`define MERGE_CONT_3_5 5'b10110
|
|
`define MERGE_CONT_4_5 5'b10111
|
|
`define MERGE_CONT_1_6 5'b11000
|
|
`define MERGE_CONT_2_6 5'b11001
|
|
`define MERGE_CONT_3_6 5'b11010
|
|
`define MERGE_CONT_4_6 5'b11011
|
|
`define MERGE_CONT_5_6 5'b11100
|
|
|
|
|
|
|
|
module RLE_BlobMerging(clk,
|
|
//iCOMclock,
|
|
iReset,
|
|
iReadFifoEmpty,
|
|
iReadFifoData,
|
|
iWriteFifoFull,
|
|
oReadFifoRequest,
|
|
oWriteBlobData,
|
|
oWriteRequest,
|
|
oAvgSizeXaxis,
|
|
oAvgSizeYaxis
|
|
);
|
|
|
|
input clk; //module clock
|
|
//input iCOMclock; //clock for COM sub-module
|
|
input iReset; //module reset signal
|
|
input iReadFifoEmpty; //fifo empty signal from input fifo
|
|
input [127:0]iReadFifoData; //data bus from input fifo [32b y-w., 32b x-w., 32 pixel-w.,10b length, 11b Y, 11b X]
|
|
input iWriteFifoFull; //fifo full signal from output fifo
|
|
|
|
output oReadFifoRequest; //read request to input fifo
|
|
output [75:0]oWriteBlobData; //data bus to output fifo [10b index, 11b bb y, 11b bb x, 11b com y, 11b com x, 11b len y, 11b len x]
|
|
output oWriteRequest; //write request to output fifo
|
|
output [10:0] oAvgSizeXaxis; //average size of X axis for detected BLOBs
|
|
output [10:0] oAvgSizeYaxis; //average size of Y axis for detected BLOBs
|
|
|
|
reg oReadFifoRequest; //read request to input fifo
|
|
reg [75:0]oWriteBlobData; //data bus to output fifo [10b index, 11b bb y, 11b bb x, 11b com y, 11b com x, 11b len y, 11b len x]
|
|
reg oWriteRequest; //write request to output fifo
|
|
reg [10:0] oAvgSizeXaxis; //average size of X axis for detected BLOBs
|
|
reg [10:0] oAvgSizeYaxis; //average size of Y axis for detected BLOBs
|
|
|
|
/*
|
|
parameter LSB_X=0, MSB_X=10; //start and end bit for x coordiante
|
|
parameter LSB_Y=11, MSB_Y=21; //start and end bit for y coordiante
|
|
parameter LSB_RunLength=22, MSB_RunLength=31; //start and end bit for RUN length
|
|
parameter LSB_RunSumValues=32, MSB_RunSumValues=63;
|
|
parameter LSB_RunSumXpositions=64, MSB_RunSumXpositions=95;
|
|
parameter LSB_RunSumYpositions=96, MSB_RunSumYpositions=127;
|
|
parameter LSB_EOFflag=0, MSB_EOFflag=31;//start and end bit for EOF flag
|
|
parameter CONT_RANGE = 5'd10;
|
|
parameter BLOB_RANGE = 5'd10;
|
|
parameter MIN_X=11'd0, MAX_X=11'd640, MIN_Y=11'd0, MAX_Y=11'd480;
|
|
parameter COM_DELAY_TIME=3'd5;
|
|
*/
|
|
|
|
//internal registers
|
|
reg [17:0] checkResult; //each flage represents one result of conditional checks
|
|
reg [9:0] run_length; //temporary store the length of a detected run
|
|
reg [10:0] run_start_x; //temporary store starting X position of run
|
|
reg [10:0] run_start_y; //temporary store starting Y position of run
|
|
reg [31:0] run_sum_x_positions; //temporary store weighted sum of x positions in run
|
|
reg [31:0] run_sum_y_positions; //temporary store weighted sum of y postions in run
|
|
reg [31:0] run_sum_values; //temporary store sum of weights in run
|
|
reg [3:0] write_result_pointer;
|
|
reg [4:0] state;
|
|
reg RunAdded;
|
|
reg [14:0] ContainerAdjacentResult;
|
|
reg [3:0] countDetectedBlobs;
|
|
reg [10:0] avgSizeXaxis;
|
|
reg [10:0] avgSizeYaxis;
|
|
reg enableCOMcomputation; //flag enables sub-modules for center point computation with COM
|
|
reg [3:0] delayCounterCOM; //counts up to COM_DELAY_TIME to allow sub-module finish computation
|
|
|
|
//BLOB containers
|
|
//CONTAINER 1
|
|
reg[10:0] blob1minX, blob1minY, blob1maxX, blob1maxY; //bounding box attributes
|
|
reg [10:0] blob1X_bb_center, blob1Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob1X_com_center, blob1Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_1; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_1; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_1; //number of pixels belonging to BLOB
|
|
reg blob1empty; //flag information if container is empty
|
|
|
|
//CONTAINER 2
|
|
reg[10:0] blob2minX, blob2minY, blob2maxX, blob2maxY; //bounding box attributes
|
|
reg [10:0] blob2X_bb_center, blob2Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob2X_com_center, blob2Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_2; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_2; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_2; //number of pixels belonging to BLOB
|
|
reg blob2empty; //flag information if container is empty
|
|
|
|
//CONTAINER 3
|
|
reg[10:0] blob3minX, blob3minY, blob3maxX, blob3maxY; //bounding box attributes
|
|
reg [10:0] blob3X_bb_center, blob3Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob3X_com_center, blob3Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_3; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_3; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_3; //number of pixels belonging to BLOB
|
|
reg blob3empty; //flag information if container is empty
|
|
|
|
//CONTAINER 4
|
|
reg[10:0] blob4minX, blob4minY, blob4maxX, blob4maxY; //bounding box attributes
|
|
reg [10:0] blob4X_bb_center, blob4Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob4X_com_center, blob4Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_4; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_4; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_4; //number of pixels belonging to BLOB
|
|
reg blob4empty; //flag information if container is empty
|
|
|
|
//CONTAINER 5
|
|
reg[10:0] blob5minX, blob5minY, blob5maxX, blob5maxY; //bounding box attributes
|
|
reg [10:0] blob5X_bb_center, blob5Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob5X_com_center, blob5Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_5; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_5; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_5; //number of pixels belonging to BLOB
|
|
reg blob5empty; //flag information if container is empty
|
|
|
|
//CONTAINER 6
|
|
reg[10:0] blob6minX, blob6minY, blob6maxX, blob6maxY; //bounding box attributes
|
|
reg [10:0] blob6X_bb_center, blob6Y_bb_center; //center points for bounding box attributes
|
|
reg [35:0] blob6X_com_center, blob6Y_com_center; //center points for center of mass attributes
|
|
reg [35:0] sumBLOB_Xpositions_6; //summed X positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Ypositions_6; //summed Y positions of all pixels belonging to BLOB, weightend by pixel value
|
|
reg [35:0] sumBLOB_Pixels_6; //number of pixels belonging to BLOB
|
|
reg blob6empty; //flag information if container is empty
|
|
|
|
//divider varaible
|
|
|
|
//reg [49:0]divider_res_x;
|
|
wire [10:0]divider_res_x;
|
|
//reg [49:0]divider_rem_x;
|
|
wire [10:0]divider_rem_x;
|
|
|
|
wire [10:0]divider_res_y;
|
|
//reg [49:0]divider_res_y;
|
|
wire [10:0]divider_rem_y;
|
|
//reg [49:0]divider_rem_y;
|
|
|
|
wire [10:0] ex_avgSizeXaxis;
|
|
//reg [49:0] ex_avgSizeXaxis;
|
|
assign ex_avgSizeXaxis = avgSizeXaxis;
|
|
|
|
wire [10:0]ex_avgSizeYaxis;
|
|
//reg [49:0]ex_avgSizeYaxis;
|
|
assign ex_avgSizeYaxis = avgSizeYaxis;
|
|
|
|
|
|
wire [3:0]ex_countDetectedBlobs;
|
|
//reg [49:0]ex_countDetectedBlobs;
|
|
assign ex_countDetectedBlobs = countDetectedBlobs;
|
|
//implement the divider
|
|
divider inst_x (
|
|
.opa(ex_avgSizeXaxis),
|
|
.opb(ex_countDetectedBlobs),
|
|
.quo(divider_res_x),
|
|
.rem(divider_rem_x));
|
|
|
|
divider inst_y (
|
|
.opa(ex_avgSizeYaxis),
|
|
.opb(ex_countDetectedBlobs),
|
|
.quo(divider_res_y),
|
|
.rem(divider_rem_y));
|
|
|
|
//read RLE encoded pixel data from input fifo and merge adjacent runs to blobs
|
|
//compute blobs center points, on EOF flag
|
|
//store center points to output fifo, if EOF flag is read from Fifo
|
|
always@(posedge clk) begin
|
|
|
|
//reset internal registers on reset signal
|
|
if(iReset) begin
|
|
state <= `INIT;
|
|
end
|
|
else begin
|
|
//module state machine
|
|
case(state)
|
|
|
|
//intialize internal register
|
|
`INIT: begin
|
|
checkResult <= 18'b000000000000000000;
|
|
run_length <= 10'b0000000000;
|
|
run_start_x <= 11'b00000000000;
|
|
run_start_y <= 11'b00000000000;
|
|
|
|
RunAdded <= `FALSE;
|
|
|
|
//set defaults for CONTAINER 1
|
|
blob1maxX <= 11'b00000000000;
|
|
blob1minX <= 11'b00000000000;
|
|
blob1maxY <= 11'b00000000000;
|
|
blob1minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_1=0;
|
|
// sumBLOB_Ypositions_1=0;
|
|
// sumBLOB_Pixels_1=0;
|
|
blob1empty <= `TRUE;
|
|
|
|
//set defaults for CONTAINER 2
|
|
blob2maxX <= 11'b00000000000;
|
|
blob2minX <= 11'b00000000000;
|
|
blob2maxY <= 11'b00000000000;
|
|
blob2minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_2=0;
|
|
// sumBLOB_Ypositions_2=0;
|
|
// sumBLOB_Pixels_2=0;
|
|
blob2empty <= `TRUE;
|
|
|
|
//set defaults for CONTAINER 3
|
|
blob3maxX <= 11'b00000000000;
|
|
blob3minX <= 11'b00000000000;
|
|
blob3maxY <= 11'b00000000000;
|
|
blob3minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_3=0;
|
|
// sumBLOB_Ypositions_3=0;
|
|
// sumBLOB_Pixels_3=0;
|
|
blob3empty <= `TRUE;
|
|
|
|
//set defaults for CONTAINER 4
|
|
blob4maxX <= 11'b00000000000;
|
|
blob4minX <= 11'b00000000000;
|
|
blob4maxY <= 11'b00000000000;
|
|
blob4minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_4=0;
|
|
// sumBLOB_Ypositions_4=0;
|
|
// sumBLOB_Pixels_4=0;
|
|
blob4empty <= `TRUE;
|
|
|
|
|
|
//set defaults for CONTAINER 5
|
|
blob5maxX <= 11'b00000000000;
|
|
blob5minX <= 11'b00000000000;
|
|
blob5maxY <= 11'b00000000000;
|
|
blob5minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_5=0;
|
|
// sumBLOB_Ypositions_5=0;
|
|
// sumBLOB_Pixels_5=0;
|
|
blob5empty <= `TRUE;
|
|
|
|
//set defaults for CONTAINER 6
|
|
blob6maxX <= 11'b00000000000;
|
|
blob6minX <= 11'b00000000000;
|
|
blob6maxY <= 11'b00000000000;
|
|
blob6minY <= 11'b00000000000;
|
|
// sumBLOB_Xpositions_6<=0;
|
|
// sumBLOB_Ypositions_6<=0;
|
|
// sumBLOB_Pixels_6<=0;
|
|
blob6empty <= `TRUE;
|
|
|
|
|
|
blob1X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob1Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob2X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob2Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob3X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob3Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob4X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob4Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob5X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob5Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob6X_com_center <= 35'b00000000000000000000000000000000000;
|
|
blob6Y_com_center <= 35'b00000000000000000000000000000000000;
|
|
//blob4X_com_center
|
|
//blob4X_com_center
|
|
|
|
|
|
avgSizeXaxis<=11'b00000000000;
|
|
avgSizeYaxis<=11'b00000000000;
|
|
countDetectedBlobs<=4'b0000;
|
|
enableCOMcomputation<=`FALSE;
|
|
|
|
state <= `IDLE;
|
|
end
|
|
|
|
//read run data from input fifo
|
|
`IDLE: begin
|
|
if(!iReadFifoEmpty) begin
|
|
oReadFifoRequest <= `TRUE;
|
|
state <= `READ_FIFO;
|
|
end
|
|
else begin
|
|
state <= `IDLE;
|
|
end
|
|
end
|
|
|
|
//receive data from input fifo
|
|
`READ_FIFO: begin
|
|
oReadFifoRequest <= `FALSE;
|
|
|
|
//check for EOF flag
|
|
if(iReadFifoData[`MSB_EOFflag:`LSB_EOFflag]==`EOF)begin
|
|
write_result_pointer<=4'b0000;
|
|
|
|
//start center point computation for COM
|
|
enableCOMcomputation<=`TRUE;
|
|
delayCounterCOM<=4'b0000; //reset delay time counter
|
|
|
|
state <= `COMPUTE_CENTER;
|
|
end
|
|
else begin
|
|
run_length <= iReadFifoData[31:22];
|
|
run_start_x <= iReadFifoData[10:0];
|
|
run_start_y <= iReadFifoData[21:11];
|
|
run_sum_x_positions <= iReadFifoData[95:64];
|
|
run_sum_y_positions <= iReadFifoData[127:96];
|
|
run_sum_values <= iReadFifoData[63:32];
|
|
checkResult <= 18'b000000000000000000;
|
|
RunAdded <= `FALSE;
|
|
state <= `CHECK_CONDITIONS;
|
|
end
|
|
end
|
|
|
|
//perform condition checks
|
|
`CHECK_CONDITIONS: begin
|
|
|
|
//check which BLOB containers are empty
|
|
checkResult[0] <= blob1empty;
|
|
checkResult[3] <= blob2empty;
|
|
checkResult[6] <= blob3empty;
|
|
checkResult[9] <= blob4empty;
|
|
checkResult[12] <= blob5empty;
|
|
checkResult[15] <= blob6empty;
|
|
|
|
|
|
//check if run is adjacent on X values to blob 1 container
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob1minX) & (run_start_x <= (blob1maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob1minX) & ((run_start_x+run_length) <= (blob1maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[1] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on X values to blob 2 container
|
|
// if( ((run_start_x+`BLOB_RANGE) >= blob2minX) & (run_start_x <= blob2maxX) &
|
|
// ((run_start_x+run_length) >= blob2minX) & ((run_start_x+run_length) <= (blob2maxX+`BLOB_RANGE)) ) begin
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob2minX) & (run_start_x <= (blob2maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob2minX) & ((run_start_x+run_length) <= (blob2maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[4] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on X values to blob 3 container
|
|
// if( ((run_start_x+`BLOB_RANGE) >= blob3minX) & (run_start_x <= blob3maxX) &
|
|
// ((run_start_x+run_length) >= blob3minX) & ((run_start_x+run_length) <= (blob3maxX+`BLOB_RANGE)) ) begin
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob3minX) & (run_start_x <= (blob3maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob3minX) & ((run_start_x+run_length) <= (blob3maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[7] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on X values to blob 4 container
|
|
// if( ((run_start_x+`BLOB_RANGE) >= blob4minX) & (run_start_x <= blob4maxX) &
|
|
// ((run_start_x+run_length) >= blob4minX) & ((run_start_x+run_length) <= (blob4maxX+`BLOB_RANGE)) ) begin
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob4minX) & (run_start_x <= (blob4maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob4minX) & ((run_start_x+run_length) <= (blob4maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[10] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on X values to blob 5 container
|
|
// if( ((run_start_x+`BLOB_RANGE) >= blob5minX) & (run_start_x <= blob5maxX) &
|
|
// ((run_start_x+run_length) >= blob5minX) & ((run_start_x+run_length) <= (blob5maxX+`BLOB_RANGE)) ) begin
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob5minX) & (run_start_x <= (blob5maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob5minX) & ((run_start_x+run_length) <= (blob5maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[13] <= `TRUE;
|
|
end
|
|
|
|
//check if run is adjacent on X values to blob 6 container
|
|
if( (((run_start_x+`BLOB_RANGE) >= blob6minX) & (run_start_x <= (blob6maxX+`BLOB_RANGE))) ||
|
|
((run_start_x+run_length+`BLOB_RANGE) >= blob6minX) & ((run_start_x+run_length) <= (blob6maxX+`BLOB_RANGE)) ) begin
|
|
checkResult[16] <= `TRUE;
|
|
end
|
|
|
|
//check if run is adjacent on Y values to blob 1 container
|
|
if( (run_start_y == (blob1maxY +1)) || (run_start_y == blob1maxY) ) begin
|
|
checkResult[2] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on Y values to blob 2 container
|
|
if( (run_start_y == (blob2maxY +1)) || (run_start_y == blob2maxY) ) begin
|
|
checkResult[5] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on Y values to blob 3 container
|
|
if( (run_start_y == (blob3maxY +1)) || (run_start_y == blob3maxY) ) begin
|
|
checkResult[8] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on Y values to blob 4 container
|
|
if( (run_start_y == (blob4maxY +1)) || (run_start_y == blob4maxY) ) begin
|
|
checkResult[11] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on Y values to blob 5 container
|
|
if( (run_start_y == (blob5maxY +1)) || (run_start_y == blob5maxY) ) begin
|
|
checkResult[14] <= `TRUE;
|
|
end
|
|
//check if run is adjacent on Y values to blob 5 container
|
|
if( (run_start_y == (blob6maxY +1)) || (run_start_y == blob6maxY) ) begin
|
|
checkResult[17] <= `TRUE;
|
|
end
|
|
|
|
state <= `CHECK_ADJACENT_CONTAINTER;
|
|
end
|
|
|
|
//validate results from condition check for adjacency
|
|
`CHECK_ADJACENT_CONTAINTER: begin
|
|
|
|
if(
|
|
((~checkResult[0])&checkResult[1]&checkResult[2])
|
|
|| ((~checkResult[3])&checkResult[4]&checkResult[5])
|
|
|| ((~checkResult[6])&checkResult[7]&checkResult[8])
|
|
|| ((~checkResult[9])&checkResult[10]&checkResult[11])
|
|
|| ((~checkResult[12])&checkResult[13]&checkResult[14])
|
|
|| ((~checkResult[15])&checkResult[16]&checkResult[17])
|
|
)
|
|
begin
|
|
RunAdded <= `TRUE;
|
|
end
|
|
|
|
//run adjacent to container 1
|
|
if( (~checkResult[0])&checkResult[1]&checkResult[2] )
|
|
begin
|
|
if(run_start_x < blob1minX) blob1minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob1maxX) blob1maxX <= (run_start_x+run_length);
|
|
if(blob1maxY < run_start_y) blob1maxY <= run_start_y;
|
|
end
|
|
|
|
//run adjacent to container 2
|
|
if( (~checkResult[3])&checkResult[4]&checkResult[5] )
|
|
begin
|
|
if(run_start_x < blob2minX) blob2minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob2maxX) blob2maxX <= (run_start_x+run_length);
|
|
if(blob2maxY < run_start_y) blob2maxY <= run_start_y;
|
|
end
|
|
|
|
//run adjacent to container 3
|
|
if( (~checkResult[6])&checkResult[7]&checkResult[8] )
|
|
begin
|
|
if(run_start_x < blob3minX) blob3minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob3maxX) blob3maxX <= (run_start_x+run_length);
|
|
if(blob3maxY < run_start_y) blob3maxY <= run_start_y;
|
|
end
|
|
|
|
//run adjacent to container 4
|
|
if( (~checkResult[9])&checkResult[10]&checkResult[11] )
|
|
begin
|
|
if(run_start_x < blob4minX) blob4minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob4maxX) blob4maxX <= (run_start_x+run_length);
|
|
if(blob4maxY < run_start_y) blob4maxY <= run_start_y;
|
|
end
|
|
|
|
//run adjacent to container 5
|
|
if( (~checkResult[12])&checkResult[13]&checkResult[14] )
|
|
begin
|
|
if(run_start_x < blob5minX) blob5minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob5maxX) blob5maxX <= (run_start_x+run_length);
|
|
if(blob5maxY < run_start_y) blob5maxY <= run_start_y;
|
|
end
|
|
|
|
//run adjacent to container 6
|
|
if( (~checkResult[15])&checkResult[16]&checkResult[17] )
|
|
begin
|
|
if(run_start_x < blob6minX) blob6minX <= run_start_x;
|
|
if((run_start_x+run_length) > blob6maxX) blob6maxX <= (run_start_x+run_length);
|
|
if(blob6maxY < run_start_y) blob6maxY <= run_start_y;
|
|
end
|
|
|
|
//read next run from input fifo
|
|
state <= `VALIDATE_CHECK_ADJACENT_CONTAINER;
|
|
end
|
|
|
|
//check if run could be added to container
|
|
`VALIDATE_CHECK_ADJACENT_CONTAINER: begin
|
|
//if run has been added, continue with next run
|
|
if(RunAdded) begin
|
|
state <= `CHECK_CONT_ADJACENCY;
|
|
end
|
|
//if run not adjacent, put into empty container
|
|
else begin
|
|
state <= `SELECT_EMPTY_CONTAINER;
|
|
end
|
|
end
|
|
|
|
//if run was not adjacent, add to new container
|
|
`SELECT_EMPTY_CONTAINER: begin
|
|
|
|
//first cont empty
|
|
if( checkResult[0] ) begin
|
|
blob1minX <= run_start_x;
|
|
blob1maxX <= run_start_x+run_length;
|
|
blob1minY <= run_start_y;
|
|
blob1maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_1<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_1<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_1<=run_sum_values;
|
|
|
|
blob1empty<=`FALSE;
|
|
end
|
|
|
|
//run not adjacent to existing blobs and container 2 is empty
|
|
//second cont empty
|
|
else if( checkResult[3]) begin
|
|
blob2minX <= run_start_x;
|
|
blob2maxX <= run_start_x+run_length;
|
|
blob2minY <= run_start_y;
|
|
blob2maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_2<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_2<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_2<=run_sum_values;
|
|
|
|
blob2empty<=`FALSE;
|
|
end
|
|
|
|
//run not adjacent to existing blobs and container 3 is empty
|
|
//third cont empty
|
|
if( checkResult[6]) begin
|
|
blob3minX <= run_start_x;
|
|
blob3maxX <= run_start_x+run_length;
|
|
blob3minY <= run_start_y;
|
|
blob3maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_3<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_3<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_3<=run_sum_values;
|
|
|
|
blob3empty<=`FALSE;
|
|
end
|
|
|
|
//run not adjacent to existing blobs and container 4 is empty
|
|
//fourth cont empty
|
|
else if( checkResult[9])begin
|
|
blob4minX <= run_start_x;
|
|
blob4maxX <= run_start_x+run_length;
|
|
blob4minY <= run_start_y;
|
|
blob4maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_4<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_4<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_4<=run_sum_values;
|
|
|
|
blob4empty<=`FALSE;
|
|
end
|
|
|
|
//run not adjacent to existing blobs and container 5 is empty
|
|
//fifth cont empty
|
|
else if( checkResult[12]) begin
|
|
blob5minX <= run_start_x;
|
|
blob5maxX <= run_start_x+run_length;
|
|
blob5minY <= run_start_y;
|
|
blob5maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_5<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_5<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_5<=run_sum_values;
|
|
|
|
blob5empty<=`FALSE;
|
|
end
|
|
|
|
else if( checkResult[15]) begin
|
|
blob6minX <= run_start_x;
|
|
blob6maxX <= run_start_x+run_length;
|
|
blob6minY <= run_start_y;
|
|
blob6maxY <= run_start_y;
|
|
|
|
// sumBLOB_Xpositions_6<=run_sum_x_positions;
|
|
// sumBLOB_Ypositions_6<=run_sum_y_positions;
|
|
// sumBLOB_Pixels_6<=run_sum_values;
|
|
|
|
blob6empty<=`FALSE;
|
|
end
|
|
|
|
state <= `CHECK_CONT_ADJACENCY;
|
|
end
|
|
|
|
//compute center points for non-empty containers
|
|
//center point computation with BB and COM
|
|
`COMPUTE_CENTER: begin
|
|
//compute center point for blob in Container 1
|
|
blob1X_bb_center <= ((blob1minX + blob1maxX)>>1'b1);
|
|
blob1Y_bb_center <= ((blob1minY + blob1maxY)>>1'b1);
|
|
//compute center point for blob in Container 2
|
|
blob2X_bb_center <= ((blob2minX + blob2maxX)>>1'b1);
|
|
blob2Y_bb_center <= ((blob2minY + blob2maxY)>>1'b1);
|
|
//compute center point for blob in Container 3
|
|
blob3X_bb_center <= ((blob3minX + blob3maxX)>>1'b1);
|
|
blob3Y_bb_center <= ((blob3minY + blob3maxY)>>1'b1);
|
|
//compute center point for blob in Container 4
|
|
blob4X_bb_center <= ((blob4minX + blob4maxX)>>1'b1);
|
|
blob4Y_bb_center <= ((blob4minY + blob4maxY)>>1'b1);
|
|
//compute center point for blob in Container 5
|
|
blob5X_bb_center <= ((blob5minX + blob5maxX)>>1'b1);
|
|
blob5Y_bb_center <= ((blob5minY + blob5maxY)>>1'b1);
|
|
//compute center point for blob in Container 6
|
|
blob6X_bb_center <= ((blob6minX + blob6maxX)>>1'b1);
|
|
blob6Y_bb_center <= ((blob6minY + blob6maxY)>>1'b1);
|
|
|
|
//increase delay time counter for COM computation
|
|
//delayCounterCOM<=delayCounterCOM+3'd1;
|
|
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
|
|
`CONFIG_WRITE: begin
|
|
//increase delay time counter for COM computation
|
|
//delayCounterCOM<=delayCounterCOM+3'd1;
|
|
|
|
//if(delayCounterCOM > COM_DELAY_TIME) begin
|
|
//selector for write progress
|
|
case(write_result_pointer)
|
|
|
|
`WRITE_BLOB_0: begin
|
|
//if(blob1empty==`FALSE && blob1Y > 1) begin
|
|
if(blob1empty==`FALSE) begin
|
|
//oWriteBlobData={10'd1, blob1Y, blob1X,(blob1maxY-blob1minY),(blob1maxX-blob1minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob1Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob1X_bb_center;
|
|
oWriteBlobData[42:32]<=blob1Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob1X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob1maxY-blob1minY);
|
|
oWriteBlobData[75:65]<=(blob1maxX-blob1minX);
|
|
avgSizeYaxis<=(blob1maxY-blob1minY);
|
|
avgSizeXaxis<=(blob1maxX-blob1minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+1'b1;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
`WRITE_BLOB_1: begin
|
|
//if(blob2empty==`FALSE && blob2Y > 1) begin
|
|
if(blob2empty==`FALSE) begin
|
|
//oWriteBlobData={10'd2, blob2Y, blob2X,(blob2maxY-blob2minY),(blob2maxX-blob2minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob2Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob2X_bb_center;
|
|
oWriteBlobData[42:32]<=blob2Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob2X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob2maxY-blob2minY);
|
|
oWriteBlobData[75:65]<=(blob2maxX-blob2minX);
|
|
avgSizeYaxis<=avgSizeYaxis+(blob2maxY-blob2minY);
|
|
avgSizeXaxis<=avgSizeXaxis+(blob2maxX-blob2minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+4'b0001;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
`WRITE_BLOB_2: begin
|
|
//if(blob3empty==`FALSE && blob3Y > 1) begin
|
|
if(blob3empty==`FALSE) begin
|
|
//oWriteBlobData={10'd3, blob3Y, blob3X,(blob3maxY-blob3minY),(blob3maxX-blob3minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob3Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob3X_bb_center;
|
|
oWriteBlobData[42:32]<=blob3Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob3X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob3maxY-blob3minY);
|
|
oWriteBlobData[75:65]<=(blob3maxX-blob3minX);
|
|
avgSizeYaxis<=avgSizeYaxis+(blob3maxY-blob3minY);
|
|
avgSizeXaxis<=avgSizeXaxis+(blob3maxX-blob3minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+4'b0001;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
`WRITE_BLOB_3: begin
|
|
//if(blob4empty==`FALSE && blob4Y > 1) begin
|
|
if(blob4empty==`FALSE) begin
|
|
//oWriteBlobData={10'd4, blob4Y, blob4X,(blob4maxY-blob4minY),(blob4maxX-blob4minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob4Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob4X_bb_center;
|
|
oWriteBlobData[42:32]<=blob4Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob4X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob4maxY-blob4minY);
|
|
oWriteBlobData[75:65]<=(blob4maxX-blob4minX);
|
|
avgSizeYaxis<=avgSizeYaxis+(blob4maxY-blob4minY);
|
|
avgSizeXaxis<=avgSizeXaxis+(blob4maxX-blob4minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+1'b1;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
`WRITE_BLOB_4: begin
|
|
//if(blob5empty==`FALSE && blob5Y > 1) begin
|
|
if(blob5empty==`FALSE) begin
|
|
//oWriteBlobData={10'd5, blob5Y, blob5X,(blob5maxY-blob5minY),(blob5maxX-blob5minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob5Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob5X_bb_center;
|
|
oWriteBlobData[42:32]<=blob5Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob5X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob5maxY-blob5minY);
|
|
oWriteBlobData[75:65]<=(blob5maxX-blob5minX);
|
|
avgSizeYaxis<=avgSizeYaxis+(blob5maxY-blob5minY);
|
|
avgSizeXaxis<=avgSizeXaxis+(blob5maxX-blob5minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+1'b1;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
`WRITE_BLOB_5: begin
|
|
//if(blob6empty==`FALSE && blob6Y > 1) begin
|
|
if(blob6empty==`FALSE) begin
|
|
//oWriteBlobData={10'd6, blob6Y, blob6X,(blob6maxY-blob6minY),(blob6maxX-blob6minX)};
|
|
oWriteBlobData[9:0]<=10'b0000000001;
|
|
oWriteBlobData[20:10]<=blob6Y_bb_center;
|
|
oWriteBlobData[31:21]<=blob6X_bb_center;
|
|
oWriteBlobData[42:32]<=blob6Y_com_center[10:0];
|
|
oWriteBlobData[53:43]<=blob6X_com_center[10:0];
|
|
oWriteBlobData[64:54]<=(blob6maxY-blob6minY);
|
|
oWriteBlobData[75:65]<=(blob6maxX-blob6minX);
|
|
|
|
avgSizeYaxis<=avgSizeYaxis+(blob6maxY-blob6minY);
|
|
avgSizeXaxis<=avgSizeXaxis+(blob6maxX-blob6minX);
|
|
countDetectedBlobs<=countDetectedBlobs+1'b1;
|
|
state<=`WRITE_FIFO;
|
|
end
|
|
else begin
|
|
write_result_pointer<=write_result_pointer+1'b1;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
end
|
|
|
|
default: begin
|
|
oAvgSizeXaxis<=divider_res_x;
|
|
oAvgSizeYaxis<=divider_res_y;
|
|
//oWriteBlobData<=32'h00000000;
|
|
oWriteBlobData<=0;
|
|
state<=`INIT;//continue processing pixel from new frame
|
|
end
|
|
//NO DEFAULT(DIVIDER, CONG)
|
|
endcase
|
|
//end
|
|
//end
|
|
|
|
end
|
|
|
|
|
|
|
|
`WRITE_FIFO: begin
|
|
if(!iWriteFifoFull) begin
|
|
oWriteRequest<=`TRUE;
|
|
state<=`WRITE_WAIT;
|
|
end
|
|
end
|
|
|
|
`WRITE_WAIT: begin
|
|
oWriteRequest<=`FALSE;
|
|
write_result_pointer<=write_result_pointer+1'b1;
|
|
state<=`CONFIG_WRITE;
|
|
end
|
|
|
|
`CHECK_CONT_ADJACENCY: begin
|
|
//MERGE TO CONTAINER 1
|
|
if(blob2empty==`FALSE && blob1empty==`FALSE) begin
|
|
if( ((blob2minY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2minY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob2maxY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob2maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob2minX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2minX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob2maxX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob2maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[0]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob3empty==`FALSE && blob1empty==`FALSE) begin
|
|
//check adjacency on Y axis
|
|
if( ((blob3minY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob3minY) < `CONT_RANGE) ||
|
|
((blob3minY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob3minY) < `CONT_RANGE) ||
|
|
((blob3maxY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob3maxY) < `CONT_RANGE) ||
|
|
((blob3maxY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob3maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob3minX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob3minX) < `CONT_RANGE) ||
|
|
((blob3minX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob3minX) < `CONT_RANGE) ||
|
|
((blob3maxX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob3maxX) < `CONT_RANGE) ||
|
|
((blob3maxX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob3maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[1]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob4empty==`FALSE && blob1empty==`FALSE) begin
|
|
//check adjacency on Y axis
|
|
//Merge Container 1 and 4 if adjacent
|
|
//check adjacency on Y axis
|
|
if( ((blob4minY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4minY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob4maxY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob4maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob4minX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4minX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob4maxX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob4maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[2]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob5empty==`FALSE && blob1empty==`FALSE) begin
|
|
if( ((blob5minY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5minY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob5maxY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob5maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob5minX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5minX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob5maxX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob5maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[3]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob6empty==`FALSE && blob1empty==`FALSE) begin
|
|
if( ((blob6minY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob6minY) < `CONT_RANGE) ||
|
|
((blob6minY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob6minY) < `CONT_RANGE) ||
|
|
((blob6maxY-blob1minY) < `CONT_RANGE) || ((blob1minY-blob6maxY) < `CONT_RANGE) ||
|
|
((blob6maxY-blob1maxY) < `CONT_RANGE) || ((blob1maxY-blob6maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob6minX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob6minX) < `CONT_RANGE) ||
|
|
((blob6minX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob6minX) < `CONT_RANGE) ||
|
|
((blob6maxX-blob1minX) < `CONT_RANGE) || ((blob1minX-blob6maxX) < `CONT_RANGE) ||
|
|
((blob6maxX-blob1maxX) < `CONT_RANGE) || ((blob1maxX-blob6maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[10]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
|
|
//MERGE TO CONTAINER 2
|
|
if(blob3empty==`FALSE && blob2empty==`FALSE) begin
|
|
if( ((blob2minY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2minY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob2maxY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob2maxY) < `CONT_RANGE) )begin
|
|
|
|
if( ((blob2minX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2minX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob2maxX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob2maxX) < `CONT_RANGE) )begin
|
|
ContainerAdjacentResult[4]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob4empty==`FALSE && blob2empty==`FALSE) begin
|
|
if( ((blob2minY-blob4minY) < `CONT_RANGE) || ((blob4minY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2minY-blob4maxY) < `CONT_RANGE) || ((blob4maxY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob4minY) < `CONT_RANGE) || ((blob4minY-blob2maxY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob4maxY) < `CONT_RANGE) || ((blob4maxY-blob2maxY) < `CONT_RANGE) )begin
|
|
|
|
if( ((blob2minX-blob4minX) < `CONT_RANGE) || ((blob4minX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2minX-blob4maxX) < `CONT_RANGE) || ((blob4maxX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob4minX) < `CONT_RANGE) || ((blob4minX-blob2maxX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob4maxX) < `CONT_RANGE) || ((blob4maxX-blob2maxX) < `CONT_RANGE) )begin
|
|
ContainerAdjacentResult[5]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob5empty==`FALSE && blob2empty==`FALSE) begin
|
|
if( ((blob2minY-blob5minY) < `CONT_RANGE) || ((blob5minY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2minY-blob5maxY) < `CONT_RANGE) || ((blob5maxY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob5minY) < `CONT_RANGE) || ((blob5minY-blob2maxY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob5maxY) < `CONT_RANGE) || ((blob5maxY-blob2maxY) < `CONT_RANGE) )begin
|
|
|
|
if( ((blob2minX-blob5minX) < `CONT_RANGE) || ((blob5minX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2minX-blob5maxX) < `CONT_RANGE) || ((blob5maxX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob5minX) < `CONT_RANGE) || ((blob5minX-blob2maxX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob5maxX) < `CONT_RANGE) || ((blob5maxX-blob2maxX) < `CONT_RANGE) )begin
|
|
ContainerAdjacentResult[6]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob6empty==`FALSE && blob2empty==`FALSE) begin
|
|
if( ((blob2minY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2minY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob2minY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob2maxY) < `CONT_RANGE) ||
|
|
((blob2maxY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob2maxY) < `CONT_RANGE) )begin
|
|
|
|
if( ((blob2minX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2minX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob2minX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob2maxX) < `CONT_RANGE) ||
|
|
((blob2maxX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob2maxX) < `CONT_RANGE) )begin
|
|
ContainerAdjacentResult[11]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
|
|
//MERGE CONTAINER 3
|
|
if(blob4empty==`FALSE && blob3empty==`FALSE) begin
|
|
if( ((blob4minY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4minY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob4maxY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob4maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob4minX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4minX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob4maxX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob4maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[7]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob5empty==`FALSE && blob3empty==`FALSE) begin
|
|
if( ((blob5minY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5minY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob5maxY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob5maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob5minX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5minX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob5maxX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob5maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[8]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob6empty==`FALSE && blob3empty==`FALSE) begin
|
|
if( ((blob6minY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob6minY) < `CONT_RANGE) ||
|
|
((blob6minY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob6minY) < `CONT_RANGE) ||
|
|
((blob6maxY-blob3minY) < `CONT_RANGE) || ((blob3minY-blob6maxY) < `CONT_RANGE) ||
|
|
((blob6maxY-blob3maxY) < `CONT_RANGE) || ((blob3maxY-blob6maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob6minX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob6minX) < `CONT_RANGE) ||
|
|
((blob6minX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob6minX) < `CONT_RANGE) ||
|
|
((blob6maxX-blob3minX) < `CONT_RANGE) || ((blob3minX-blob6maxX) < `CONT_RANGE) ||
|
|
((blob6maxX-blob3maxX) < `CONT_RANGE) || ((blob3maxX-blob6maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[12]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
|
|
//MERGE CONTAINER 4
|
|
if(blob5empty==`FALSE && blob4empty==`FALSE) begin
|
|
if( ((blob4minY-blob5minY) < `CONT_RANGE) || ((blob5minY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4minY-blob5maxY) < `CONT_RANGE) || ((blob5maxY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob5minY) < `CONT_RANGE) || ((blob5minY-blob4maxY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob5maxY) < `CONT_RANGE) || ((blob5maxY-blob4maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob4minX-blob5minX) < `CONT_RANGE) || ((blob5minX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4minX-blob5maxX) < `CONT_RANGE) || ((blob5maxX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob5minX) < `CONT_RANGE) || ((blob5minX-blob4maxX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob5maxX) < `CONT_RANGE) || ((blob5maxX-blob4maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[9]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
if(blob6empty==`FALSE && blob4empty==`FALSE) begin
|
|
if( ((blob4minY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4minY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob4minY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob4maxY) < `CONT_RANGE) ||
|
|
((blob4maxY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob4maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob4minX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4minX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob4minX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob4maxX) < `CONT_RANGE) ||
|
|
((blob4maxX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob4maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[13]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
//MERGE CONTAINER 5
|
|
if(blob6empty==`FALSE && blob5empty==`FALSE) begin
|
|
if( ((blob5minY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5minY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob5minY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob6minY) < `CONT_RANGE) || ((blob6minY-blob5maxY) < `CONT_RANGE) ||
|
|
((blob5maxY-blob6maxY) < `CONT_RANGE) || ((blob6maxY-blob5maxY) < `CONT_RANGE)) begin
|
|
|
|
if( ((blob5minX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5minX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob5minX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob6minX) < `CONT_RANGE) || ((blob6minX-blob5maxX) < `CONT_RANGE) ||
|
|
((blob5maxX-blob6maxX) < `CONT_RANGE) || ((blob6maxX-blob5maxX) < `CONT_RANGE)) begin
|
|
ContainerAdjacentResult[14]<=`TRUE;
|
|
end
|
|
end
|
|
end
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONTAINER: begin
|
|
if(ContainerAdjacentResult>0) begin
|
|
|
|
if(ContainerAdjacentResult[14]==1'b1) begin
|
|
state<= `MERGE_CONT_5_6;
|
|
end
|
|
else if(ContainerAdjacentResult[13]==1'b1) begin
|
|
state<= `MERGE_CONT_4_6;
|
|
end
|
|
else if(ContainerAdjacentResult[9]==1'b1) begin
|
|
state<= `MERGE_CONT_4_5;
|
|
end
|
|
else if(ContainerAdjacentResult[12]==1'b1) begin
|
|
state<= `MERGE_CONT_3_6;
|
|
end
|
|
else if(ContainerAdjacentResult[8]==1'b1) begin
|
|
state<= `MERGE_CONT_3_5;
|
|
end
|
|
else if(ContainerAdjacentResult[7]==1'b1) begin
|
|
state<= `MERGE_CONT_3_4;
|
|
end
|
|
else if(ContainerAdjacentResult[11]==1'b1) begin
|
|
state<= `MERGE_CONT_2_6;
|
|
end
|
|
else if(ContainerAdjacentResult[6]==1'b1) begin
|
|
state<= `MERGE_CONT_2_5;
|
|
end
|
|
else if(ContainerAdjacentResult[5]==1'b1) begin
|
|
state<= `MERGE_CONT_2_4;
|
|
end
|
|
else if(ContainerAdjacentResult[4]==1'b1) begin
|
|
state<= `MERGE_CONT_2_3;
|
|
end
|
|
else if(ContainerAdjacentResult[10]==1'b1) begin
|
|
state<= `MERGE_CONT_1_6;
|
|
end
|
|
else if(ContainerAdjacentResult[3]==1'b1) begin
|
|
state<= `MERGE_CONT_1_5;
|
|
end
|
|
else if(ContainerAdjacentResult[2]==1'b1) begin
|
|
state<= `MERGE_CONT_1_4;
|
|
end
|
|
else if(ContainerAdjacentResult[1]==1'b1) begin
|
|
state<= `MERGE_CONT_1_3;
|
|
end
|
|
else if(ContainerAdjacentResult[0]==1'b1) begin
|
|
state<= `MERGE_CONT_1_2;
|
|
end
|
|
|
|
|
|
end
|
|
else begin
|
|
state<=`IDLE;
|
|
end
|
|
end
|
|
|
|
`MERGE_CONT_1_2: begin
|
|
if(blob2maxX > blob1maxX) blob1maxX <= blob2maxX;
|
|
if(blob2maxY > blob1maxY) blob1maxY <= blob2maxY;
|
|
if(blob2minX < blob1minX) blob1minX <= blob2minX;
|
|
if(blob2minY < blob1minY) blob1minY <= blob2minY;
|
|
ContainerAdjacentResult[0]<=`FALSE;
|
|
blob2empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_1_3: begin
|
|
if(blob3maxX > blob1maxX) blob1maxX <= blob3maxX;
|
|
if(blob3maxY > blob1maxY) blob1maxY <= blob3maxY;
|
|
if(blob3minX < blob1minX) blob1minX <= blob3minX;
|
|
if(blob3minY < blob1minY) blob1minY <= blob3minY;
|
|
ContainerAdjacentResult[1]<=`FALSE;
|
|
blob3empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_1_4: begin
|
|
if(blob4maxX > blob1maxX) blob1maxX <= blob4maxX;
|
|
if(blob4maxY > blob1maxY) blob1maxY <= blob4maxY;
|
|
if(blob4minX < blob1minX) blob1minX <= blob4minX;
|
|
if(blob4minY < blob1minY) blob1minY <= blob4minY;
|
|
ContainerAdjacentResult[2]<=`FALSE;
|
|
blob4empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_1_5: begin
|
|
if(blob5maxX > blob1maxX) blob1maxX <= blob5maxX;
|
|
if(blob5maxY > blob1maxY) blob1maxY <= blob5maxY;
|
|
if(blob5minX < blob1minX) blob1minX <= blob5minX;
|
|
if(blob5minY < blob1minY) blob1minY <= blob5minY;
|
|
ContainerAdjacentResult[3]<=`FALSE;
|
|
blob5empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_1_6: begin
|
|
if(blob6maxX > blob1maxX) blob1maxX <= blob6maxX;
|
|
if(blob6maxY > blob1maxY) blob1maxY <= blob6maxY;
|
|
if(blob6minX < blob1minX) blob1minX <= blob6minX;
|
|
if(blob6minY < blob1minY) blob1minY <= blob6minY;
|
|
ContainerAdjacentResult[10]<=`FALSE;
|
|
blob6empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_2_3: begin
|
|
if(blob3maxX > blob2maxX) blob2maxX <= blob3maxX;
|
|
if(blob3maxY > blob2maxY) blob2maxY <= blob3maxY;
|
|
if(blob3minX < blob2minX) blob2minX <= blob3minX;
|
|
if(blob3minY < blob2minY) blob2minY <= blob3minY;
|
|
ContainerAdjacentResult[4]<=`FALSE;
|
|
blob3empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_2_4: begin
|
|
if(blob4maxX > blob2maxX) blob2maxX <= blob4maxX;
|
|
if(blob4maxY > blob2maxY) blob2maxY <= blob4maxY;
|
|
if(blob4minX < blob2minX) blob2minX <= blob4minX;
|
|
if(blob4minY < blob2minY) blob2minY <= blob4minY;
|
|
ContainerAdjacentResult[5]<=`FALSE;
|
|
blob4empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_2_5: begin
|
|
if(blob5maxX > blob2maxX) blob2maxX <= blob5maxX;
|
|
if(blob5maxY > blob2maxY) blob2maxY <= blob5maxY;
|
|
if(blob5minX < blob2minX) blob2minX <= blob5minX;
|
|
if(blob5minY < blob2minY) blob2minY <= blob5minY;
|
|
ContainerAdjacentResult[6]<=`FALSE;
|
|
blob5empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_2_6: begin
|
|
if(blob6maxX > blob2maxX) blob2maxX <= blob6maxX;
|
|
if(blob6maxY > blob2maxY) blob2maxY <= blob6maxY;
|
|
if(blob6minX < blob2minX) blob2minX <= blob6minX;
|
|
if(blob6minY < blob2minY) blob2minY <= blob6minY;
|
|
ContainerAdjacentResult[11]<=`FALSE;
|
|
blob6empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_3_4: begin
|
|
if(blob4maxX > blob3maxX) blob3maxX <= blob4maxX;
|
|
if(blob4maxY > blob3maxY) blob3maxY <= blob4maxY;
|
|
if(blob4minX < blob3minX) blob3minX <= blob4minX;
|
|
if(blob4minY < blob3minY) blob3minY <= blob4minY;
|
|
ContainerAdjacentResult[7]<=`FALSE;
|
|
blob4empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_3_5: begin
|
|
if(blob5maxX > blob3maxX) blob3maxX <= blob5maxX;
|
|
if(blob5maxY > blob3maxY) blob3maxY <= blob5maxY;
|
|
if(blob5minX < blob3minX) blob3minX <= blob5minX;
|
|
if(blob5minY < blob3minY) blob3minY <= blob5minY;
|
|
ContainerAdjacentResult[8]<=`FALSE;
|
|
blob5empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_3_6: begin
|
|
if(blob6maxX > blob3maxX) blob3maxX <= blob6maxX;
|
|
if(blob6maxY > blob3maxY) blob3maxY <= blob6maxY;
|
|
if(blob6minX < blob3minX) blob3minX <= blob6minX;
|
|
if(blob6minY < blob3minY) blob3minY <= blob6minY;
|
|
ContainerAdjacentResult[12]<=`FALSE;
|
|
blob6empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_4_5: begin
|
|
if(blob5maxX > blob4maxX) blob4maxX <= blob5maxX;
|
|
if(blob5maxY > blob4maxY) blob4maxY <= blob5maxY;
|
|
if(blob5minX < blob4minX) blob4minX <= blob5minX;
|
|
if(blob5minY < blob4minY) blob4minY <= blob5minY;
|
|
ContainerAdjacentResult[9]<=`FALSE;
|
|
blob5empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_4_6: begin
|
|
if(blob6maxX > blob4maxX) blob4maxX <= blob6maxX;
|
|
if(blob6maxY > blob4maxY) blob4maxY <= blob6maxY;
|
|
if(blob6minX < blob4minX) blob4minX <= blob6minX;
|
|
if(blob6minY < blob4minY) blob4minY <= blob6minY;
|
|
ContainerAdjacentResult[13]<=`FALSE;
|
|
blob6empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
`MERGE_CONT_5_6: begin
|
|
if(blob6maxX > blob5maxX) blob5maxX <= blob6maxX;
|
|
if(blob6maxY > blob5maxY) blob5maxY <= blob6maxY;
|
|
if(blob6minX < blob5minX) blob5minX <= blob6minX;
|
|
if(blob6minY < blob5minY) blob5minY <= blob6minY;
|
|
ContainerAdjacentResult[14]<=`FALSE;
|
|
blob6empty<=`TRUE;
|
|
|
|
state<= `MERGE_CONTAINER;
|
|
end
|
|
|
|
endcase
|
|
end
|
|
end
|
|
|
|
|
|
//perform center of mass computation
|
|
//delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation1(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_1),
|
|
// .inSumPosX(sumBLOB_Xpositions_1),
|
|
// .inSumPosY(sumBLOB_Ypositions_1),
|
|
// .outBlobXcenter(blob1X_com_center),
|
|
// .outBlobYcenter(blob1Y_com_center));
|
|
//
|
|
////perform center of mass computation
|
|
////delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation2(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_2),
|
|
// .inSumPosX(sumBLOB_Xpositions_2),
|
|
// .inSumPosY(sumBLOB_Ypositions_2),
|
|
// .outBlobXcenter(blob2X_com_center),
|
|
// .outBlobYcenter(blob2Y_com_center));
|
|
//
|
|
////perform center of mass computation
|
|
////delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation3(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_3),
|
|
// .inSumPosX(sumBLOB_Xpositions_3),
|
|
// .inSumPosY(sumBLOB_Ypositions_3),
|
|
// .outBlobXcenter(blob3X_com_center),
|
|
// .outBlobYcenter(blob3Y_com_center));
|
|
//
|
|
////perform center of mass computation
|
|
////delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation4(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_4),
|
|
// .inSumPosX(sumBLOB_Xpositions_4),
|
|
// .inSumPosY(sumBLOB_Ypositions_4),
|
|
// .outBlobXcenter(blob4X_com_center),
|
|
// .outBlobYcenter(blob4Y_com_center));
|
|
//
|
|
////perform center of mass computation
|
|
////delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation5(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_5),
|
|
// .inSumPosX(sumBLOB_Xpositions_5),
|
|
// .inSumPosY(sumBLOB_Ypositions_5),
|
|
// .outBlobXcenter(blob5X_com_center),
|
|
// .outBlobYcenter(blob5Y_com_center));
|
|
//
|
|
//
|
|
////perform center of mass computation
|
|
////delay of 1 clock tick
|
|
//CenterOfMass BlobCenterComputation6(
|
|
// .iCLK(iCOMclock),
|
|
// .iEnable(enableCOMcomputation),
|
|
// .inSumPixels(sumBLOB_Pixels_6),
|
|
// .inSumPosX(sumBLOB_Xpositions_6),
|
|
// .inSumPosY(sumBLOB_Ypositions_6),
|
|
// .outBlobXcenter(blob6X_com_center),
|
|
// .outBlobYcenter(blob6Y_com_center));
|
|
|
|
endmodule
|
|
|
|
|
|
module divider(//clk,
|
|
opa, opb, quo, rem
|
|
//testy , testy2, testy_diff, dividend_test
|
|
);
|
|
input [10:0] opa;
|
|
input [3:0] opb;
|
|
output [10:0] quo, rem;
|
|
//input clk;
|
|
//output [49:0] testy;
|
|
//output [49:0] testy2;
|
|
//output [49:0] testy_diff;
|
|
//output [49:0] dividend_test;
|
|
|
|
|
|
//assign testy_diff = diff27;
|
|
//assign testy = quotient26;
|
|
//assign testy2 = divider_copy26;
|
|
//assign dividend_test = dividend_copy26;
|
|
|
|
|
|
|
|
reg [10:0] quo, rem;
|
|
|
|
// """"""""|
|
|
// 1011 | <---- dividend_copy
|
|
// -0011 | <---- divider_copy
|
|
// """"""""| 0 Difference is negative: copy dividend and put 0 in quotient.
|
|
// 1011 | <---- dividend_copy
|
|
// -0011 | <---- divider_copy
|
|
// """"""""| 00 Difference is negative: copy dividend and put 0 in quotient.
|
|
// 1011 | <---- dividend_copy
|
|
// -0011 | <---- divider_copy
|
|
// """"""""| 001 Difference is positive: use difference and put 1 in quotient.
|
|
// quotient (numbers above)
|
|
|
|
reg [10:0] quotient0;
|
|
reg [10:0] dividend_copy0, diff0;
|
|
reg [10:0] divider_copy0;
|
|
wire [10:0] remainder0;
|
|
|
|
reg [10:0] quotient1;
|
|
reg [10:0] dividend_copy1, diff1;
|
|
reg [10:0] divider_copy1;
|
|
wire [10:0] remainder1;
|
|
|
|
reg [10:0] quotient2;
|
|
reg [10:0] dividend_copy2, diff2;
|
|
reg [10:0] divider_copy2;
|
|
wire [10:0] remainder2;
|
|
|
|
reg [10:0] quotient3;
|
|
reg [10:0] dividend_copy3, diff3;
|
|
reg [10:0] divider_copy3;
|
|
wire [10:0] remainder3;
|
|
|
|
reg [10:0] quotient4;
|
|
reg [10:0] dividend_copy4, diff4;
|
|
reg [10:0] divider_copy4;
|
|
wire [10:0] remainder4;
|
|
|
|
reg [10:0] quotient5;
|
|
reg [10:0] dividend_copy5, diff5;
|
|
reg [10:0] divider_copy5;
|
|
wire [10:0] remainder5;
|
|
|
|
reg [10:0] quotient6;
|
|
reg [10:0] dividend_copy6, diff6;
|
|
reg [10:0] divider_copy6;
|
|
wire [10:0] remainder6;
|
|
|
|
reg [10:0] quotient7;
|
|
reg [10:0] dividend_copy7, diff7;
|
|
reg [10:0] divider_copy7;
|
|
wire [10:0] remainder7;
|
|
|
|
reg [10:0] quotient8;
|
|
reg [10:0] dividend_copy8, diff8;
|
|
reg [10:0] divider_copy8;
|
|
wire [10:0] remainder8;
|
|
|
|
always @ (opa or opb)
|
|
begin
|
|
//stage initial
|
|
quotient0 = 11'b00000000000;
|
|
dividend_copy0 = opa;
|
|
divider_copy0 = {opb,7'b0000000};
|
|
|
|
//stage1
|
|
diff1 = dividend_copy0 - divider_copy0;
|
|
quotient1 [10:1] = quotient0[9:0] ;
|
|
if (!diff1[10]) // if diff1[10] == 0 (diff is positive, use difference )
|
|
begin
|
|
dividend_copy1 = diff1;
|
|
quotient1[0] = 1'b1;
|
|
end
|
|
else // diff was negative, use old dividend
|
|
begin
|
|
dividend_copy1 = dividend_copy0;
|
|
quotient1[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy1 = (divider_copy0 >> 1);
|
|
//stage2
|
|
diff2 = dividend_copy1 - divider_copy1;
|
|
quotient2[10:1] = quotient1 [9:0] ;
|
|
if (!diff2[10])
|
|
begin
|
|
dividend_copy2 = diff2;
|
|
quotient2[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy2 = dividend_copy1;
|
|
quotient2[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy2 = divider_copy1 >> 1;
|
|
|
|
//stage3
|
|
diff3 = dividend_copy2 - divider_copy2;
|
|
quotient3[10:1] = quotient2 [9:0] ;
|
|
if (!diff3[10])
|
|
begin
|
|
dividend_copy3 = diff3;
|
|
quotient3[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy3 = dividend_copy2;
|
|
quotient3[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy3 = divider_copy2 >> 1;
|
|
|
|
//stage4
|
|
diff4 = dividend_copy3 - divider_copy3;
|
|
quotient4[10:1] = quotient3 [9:0] ;
|
|
if (!diff4[10])
|
|
begin
|
|
dividend_copy4 = diff4;
|
|
quotient4[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy4 = dividend_copy3;
|
|
quotient4[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy4 = divider_copy3 >> 1;
|
|
//stage5
|
|
diff5 = dividend_copy4 - divider_copy4;
|
|
quotient5[10:1] = quotient4 [9:0] ;
|
|
if (!diff5[10])
|
|
begin
|
|
dividend_copy5 = diff5;
|
|
quotient5[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy5 = dividend_copy4;
|
|
quotient5[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy5 = divider_copy4 >> 1;
|
|
//stage6
|
|
diff6 = dividend_copy5 - divider_copy5;
|
|
quotient6[10:1] = quotient5 [9:0] ;
|
|
if (!diff6[10])
|
|
begin
|
|
dividend_copy6 = diff6;
|
|
quotient6[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy6 = dividend_copy5;
|
|
quotient6[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy6 = divider_copy5>> 1;
|
|
|
|
//stage7
|
|
diff7 = dividend_copy6 - divider_copy6;
|
|
quotient7[10:1] = quotient6 [9:0] ;
|
|
if (!diff7[10])
|
|
begin
|
|
dividend_copy7 = diff7;
|
|
quotient7[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy7 = dividend_copy6;
|
|
quotient7[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy7 = divider_copy6>> 1;
|
|
//stage8
|
|
diff8 = dividend_copy7 - divider_copy7;
|
|
quotient8[10:1] = quotient7 [9:0] ;
|
|
if (!diff8[10])
|
|
begin
|
|
dividend_copy8 = diff8;
|
|
quotient8[0] = 1'b1;
|
|
end
|
|
else
|
|
begin
|
|
dividend_copy8 = dividend_copy7;
|
|
quotient8[0] = 1'b0;
|
|
|
|
end
|
|
divider_copy8 = divider_copy7>> 1;
|
|
|
|
quo = quotient8;
|
|
rem = dividend_copy8;
|
|
|
|
end
|
|
|
|
//integer i;
|
|
|
|
/*
|
|
always @(opa,opb)
|
|
begin
|
|
for (i=-1; i<8; i=i+1)
|
|
begin
|
|
if (i==-1)
|
|
begin
|
|
// initialization
|
|
quotient = 10'd0;
|
|
dividend_copy = opa;
|
|
divider_copy = {opb,7'd0};
|
|
end
|
|
else
|
|
begin
|
|
diff = dividend_copy - divider_copy;
|
|
quotient = quotient ;
|
|
|
|
if( !diff[10] )
|
|
begin
|
|
dividend_copy = diff;
|
|
quotient[0] = 1'd1;
|
|
end
|
|
divider_copy = divider_copy >> 1;
|
|
end
|
|
end
|
|
end
|
|
*/
|
|
|
|
endmodule
|
|
|