Lines Matching refs:seq
55 #define CV_GET_LAST_ELEM( seq, block ) \
56 ((block)->data + ((block)->count - 1)*((seq)->elem_size))
447 CvSeq *seq = 0;
459 CV_CALL( seq = (CvSeq*)cvMemStorageAlloc( storage, header_size ));
460 memset( seq, 0, header_size );
462 seq->header_size = header_size;
463 seq->flags = (seq_flags & ~CV_MAGIC_MASK) | CV_SEQ_MAGIC_VAL;
474 seq->elem_size = elem_size;
475 seq->storage = storage;
477 CV_CALL( cvSetSeqBlockSize( seq, (1 << 10)/elem_size ));
481 return seq;
488 cvSetSeqBlockSize( CvSeq *seq, int delta_elements )
497 if( !seq || !seq->storage )
502 useful_block_size = cvAlignLeft(seq->storage->block_size - sizeof(CvMemBlock) -
504 elem_size = seq->elem_size;
519 seq->delta_elems = delta_elements;
527 cvGetSeqElem( const CvSeq *seq, int index )
530 int count, total = seq->total;
540 block = seq->first;
560 return block->data + index * seq->elem_size;
566 cvSeqElemIdx( const CvSeq* seq, const void* _element, CvSeqBlock** _block )
578 if( !seq || !element )
581 block = first_block = seq->first;
582 elem_size = seq->elem_size;
594 id += block->start_index - seq->first->start_index;
609 cvSliceLength( CvSlice slice, const CvSeq* seq )
611 int total = seq->total;
639 cvCvtSeqToArray( const CvSeq *seq, void *array, CvSlice slice )
649 if( !seq || !array )
652 elem_size = seq->elem_size;
653 total = cvSliceLength( slice, seq )*elem_size;
658 cvStartReadSeq( seq, &reader, 0 );
686 void *array, int total, CvSeq *seq, CvSeqBlock * block )
697 if( !seq || ((!array || !block) && total > 0) )
700 memset( seq, 0, header_size );
702 seq->header_size = header_size;
703 seq->flags = (seq_flags & ~CV_MAGIC_MASK) | CV_SEQ_MAGIC_VAL;
714 seq->elem_size = elem_size;
715 seq->total = total;
716 seq->block_max = seq->ptr = (schar *) array + total * elem_size;
720 seq->first = block;
727 result = seq;
736 If there are free sequence blocks (seq->free_blocks != 0)
739 icvGrowSeq( CvSeq *seq, int in_front_of )
747 if( !seq )
749 block = seq->free_blocks;
753 int elem_size = seq->elem_size;
754 int delta_elems = seq->delta_elems;
755 CvMemStorage *storage = seq->storage;
757 if( seq->total >= delta_elems*4 )
758 cvSetSeqBlockSize( seq, delta_elems*2 );
766 if( (unsigned)(ICV_FREE_PTR(storage) - seq->block_max) < CV_STRUCT_ALIGN &&
767 storage->free_space >= seq->elem_size && !in_front_of )
772 seq->block_max += delta;
774 seq->block_max), CV_STRUCT_ALIGN );
789 delta = (storage->free_space - ICV_ALIGNED_SEQ_BLOCK_SIZE)/seq->elem_size;
790 delta = delta*seq->elem_size + ICV_ALIGNED_SEQ_BLOCK_SIZE;
807 seq->free_blocks = block->next;
810 if( !(seq->first) )
812 seq->first = block;
817 block->prev = seq->first->prev;
818 block->next = seq->first;
828 assert( block->count % seq->elem_size == 0 && block->count > 0 );
832 seq->ptr = block->data;
833 seq->block_max = block->data + block->count;
839 int delta = block->count / seq->elem_size;
844 assert( seq->first->start_index == 0 );
845 seq->first = block;
849 seq->block_max = seq->ptr = block->data;
858 if( block == seq->first )
870 icvFreeSeqBlock( CvSeq *seq, int in_front_of )
876 CvSeqBlock *block = seq->first;
882 block->count = (int)(seq->block_max - block->data) + block->start_index * seq->elem_size;
883 block->data = seq->block_max - block->count;
884 seq->first = 0;
885 seq->ptr = seq->block_max = 0;
886 seq->total = 0;
893 assert( seq->ptr == block->data );
895 block->count = (int)(seq->block_max - seq->ptr);
896 seq->block_max = seq->ptr = block->prev->data +
897 block->prev->count * seq->elem_size;
903 block->count = delta * seq->elem_size;
911 if( block == seq->first )
915 seq->first = block->next;
922 assert( block->count > 0 && block->count % seq->elem_size == 0 );
923 block->next = seq->free_blocks;
924 seq->free_blocks = block;
936 cvStartAppendToSeq( CvSeq *seq, CvSeqWriter * writer )
942 if( !seq || !writer )
948 writer->seq = seq;
949 writer->block = seq->first ? seq->first->prev : 0;
950 writer->ptr = seq->ptr;
951 writer->block_max = seq->block_max;
962 CvSeq *seq = 0;
971 CV_CALL( seq = cvCreateSeq( seq_flags, header_size, elem_size, storage ));
972 cvStartAppendToSeq( seq, writer );
982 CvSeq *seq = 0;
991 seq = writer->seq;
992 seq->ptr = writer->ptr;
997 CvSeqBlock *first_block = writer->seq->first;
1000 writer->block->count = (int)((writer->ptr - writer->block->data) / seq->elem_size);
1010 writer->seq->total = total;
1021 CvSeq *seq = 0;
1031 seq = writer->seq;
1034 if( writer->block && writer->seq->storage )
1036 CvMemStorage *storage = seq->storage;
1042 - seq->block_max) < CV_STRUCT_ALIGN )
1044 storage->free_space = cvAlignLeft((int)(storage_block_max - seq->ptr), CV_STRUCT_ALIGN);
1045 seq->block_max = seq->ptr;
1053 return seq;
1065 CvSeq *seq;
1067 if( !writer || !writer->seq )
1070 seq = writer->seq;
1074 CV_CALL( icvGrowSeq( seq, 0 ));
1076 writer->block = seq->first->prev;
1077 writer->ptr = seq->ptr;
1078 writer->block_max = seq->block_max;
1090 cvStartReadSeq( const CvSeq *seq, CvSeqReader * reader, int reverse )
1099 reader->seq = 0;
1106 if( !seq || !reader )
1110 reader->seq = (CvSeq*)seq;
1112 first_block = seq->first;
1118 reader->prev_elem = CV_GET_LAST_ELEM( seq, last_block );
1119 reader->delta_index = seq->first->start_index;
1136 reader->block_max = reader->block_min + reader->block->count * seq->elem_size;
1173 reader->ptr = CV_GET_LAST_ELEM( reader->seq, reader->block );
1176 reader->block_max = reader->block_min + reader->block->count * reader->seq->elem_size;
1196 elem_size = reader->seq->elem_size;
1224 if( !reader || !reader->seq )
1227 total = reader->seq->total;
1228 elem_size = reader->seq->elem_size;
1245 block = reader->seq->first;
1314 cvSeqPush( CvSeq *seq, void *element )
1323 if( !seq )
1326 elem_size = seq->elem_size;
1327 ptr = seq->ptr;
1329 if( ptr >= seq->block_max )
1331 CV_CALL( icvGrowSeq( seq, 0 ));
1333 ptr = seq->ptr;
1334 assert( ptr + elem_size <= seq->block_max /*&& ptr == seq->block_min */ );
1339 seq->first->prev->count++;
1340 seq->total++;
1341 seq->ptr = ptr + elem_size;
1351 cvSeqPop( CvSeq *seq, void *element )
1360 if( !seq )
1362 if( seq->total <= 0 )
1365 elem_size = seq->elem_size;
1366 seq->ptr = ptr = seq->ptr - elem_size;
1370 seq->ptr = ptr;
1371 seq->total--;
1373 if( --(seq->first->prev->count) == 0 )
1375 icvFreeSeqBlock( seq, 0 );
1376 assert( seq->ptr == seq->block_max );
1385 cvSeqPushFront( CvSeq *seq, void *element )
1395 if( !seq )
1398 elem_size = seq->elem_size;
1399 block = seq->first;
1403 CV_CALL( icvGrowSeq( seq, 1 ));
1405 block = seq->first;
1415 seq->total++;
1425 cvSeqPopFront( CvSeq *seq, void *element )
1434 if( !seq )
1436 if( seq->total <= 0 )
1439 elem_size = seq->elem_size;
1440 block = seq->first;
1446 seq->total--;
1450 icvFreeSeqBlock( seq, 1 );
1458 cvSeqInsert( CvSeq *seq, int before_index, void *element )
1471 if( !seq )
1474 total = seq->total;
1483 CV_CALL( ret_ptr = cvSeqPush( seq, element ));
1487 CV_CALL( ret_ptr = cvSeqPushFront( seq, element ));
1491 elem_size = seq->elem_size;
1495 schar *ptr = seq->ptr + elem_size;
1497 if( ptr > seq->block_max )
1499 CV_CALL( icvGrowSeq( seq, 0 ));
1501 ptr = seq->ptr + elem_size;
1502 assert( ptr <= seq->block_max );
1505 delta_index = seq->first->start_index;
1506 block = seq->first->prev;
1520 assert( block != seq->first->prev );
1531 seq->ptr = ptr;
1535 block = seq->first;
1539 CV_CALL( icvGrowSeq( seq, 1 ));
1541 block = seq->first;
1559 assert( block != seq->first );
1571 seq->total = total + 1;
1582 cvSeqRemove( CvSeq *seq, int index )
1595 if( !seq )
1598 total = seq->total;
1608 cvSeqPop( seq, 0 );
1612 cvSeqPopFront( seq, 0 );
1616 block = seq->first;
1617 elem_size = seq->elem_size;
1629 while( block != seq->first->prev ) /* while not the last block */
1641 seq->ptr -= elem_size;
1648 while( block != seq->first )
1663 seq->total = total - 1;
1665 icvFreeSeqBlock( seq, front );
1674 cvSeqPushMulti( CvSeq *seq, void *_elements, int count, int front )
1683 if( !seq )
1688 elem_size = seq->elem_size;
1694 int delta = (int)((seq->block_max - seq->ptr) / elem_size);
1699 seq->first->prev->count += delta;
1700 seq->total += delta;
1705 memcpy( seq->ptr, elements, delta );
1708 seq->ptr += delta;
1712 CV_CALL( icvGrowSeq( seq, 0 ));
1717 CvSeqBlock* block = seq->first;
1725 CV_CALL( icvGrowSeq( seq, 1 ));
1727 block = seq->first;
1735 seq->total += delta;
1750 cvSeqPopMulti( CvSeq *seq, void *_elements, int count, int front )
1758 if( !seq )
1763 count = MIN( count, seq->total );
1768 elements += count * seq->elem_size;
1772 int delta = seq->first->prev->count;
1777 seq->first->prev->count -= delta;
1778 seq->total -= delta;
1780 delta *= seq->elem_size;
1781 seq->ptr -= delta;
1786 memcpy( elements, seq->ptr, delta );
1789 if( seq->first->prev->count == 0 )
1790 icvFreeSeqBlock( seq, 0 );
1797 int delta = seq->first->count;
1802 seq->first->count -= delta;
1803 seq->total -= delta;
1805 seq->first->start_index += delta;
1806 delta *= seq->elem_size;
1810 memcpy( elements, seq->first->data, delta );
1814 seq->first->data += delta;
1815 if( seq->first->count == 0 )
1816 icvFreeSeqBlock( seq, 1 );
1826 cvClearSeq( CvSeq *seq )
1832 if( !seq )
1834 cvSeqPopMulti( seq, 0, seq->total );
1841 cvSeqSlice( const CvSeq* seq, CvSlice slice, CvMemStorage* storage, int copy_data )
1853 if( !CV_IS_SEQ(seq) )
1858 storage = seq->storage;
1863 elem_size = seq->elem_size;
1864 length = cvSliceLength( slice, seq );
1866 slice.start_index += seq->total;
1867 else if( slice.start_index >= seq->total )
1868 slice.start_index -= seq->total;
1869 if( (unsigned)length > (unsigned)seq->total ||
1870 ((unsigned)slice.start_index >= (unsigned)seq->total && length != 0) )
1873 CV_CALL( subseq = cvCreateSeq( seq->flags, seq->header_size, elem_size, storage ));
1877 cvStartReadSeq( seq, &reader, 0 );
1924 cvSeqRemoveSlice( CvSeq* seq, CvSlice slice )
1932 if( !CV_IS_SEQ(seq) )
1935 length = cvSliceLength( slice, seq );
1936 total = seq->total;
1951 int elem_size = seq->elem_size;
1953 cvStartReadSeq( seq, &reader_to );
1954 cvStartReadSeq( seq, &reader_from );
1958 int i, count = seq->total - slice.end_index;
1969 cvSeqPopMulti( seq, 0, slice.end_index - slice.start_index );
1985 cvSeqPopMulti( seq, 0, slice.end_index - slice.start_index, 1 );
1990 cvSeqPopMulti( seq, 0, total - slice.start_index );
1991 cvSeqPopMulti( seq, 0, slice.end_index - total, 1 );
2001 cvSeqInsertSlice( CvSeq* seq, int index, const CvArr* from_arr )
2013 if( !CV_IS_SEQ(seq) )
2031 if( seq->elem_size != from->elem_size )
2040 total = seq->total;
2047 elem_size = seq->elem_size;
2051 cvSeqPushMulti( seq, 0, from_total, 1 );
2053 cvStartReadSeq( seq, &reader_to );
2054 cvStartReadSeq( seq, &reader_from );
2066 cvSeqPushMulti( seq, 0, from_total );
2068 cvStartReadSeq( seq, &reader_to );
2069 cvStartReadSeq( seq, &reader_from );
2071 cvSetSeqReaderPos( &reader_to, seq->total );
2162 cvSeqSort( CvSeq* seq, CvCmpFunc cmp_func, void* aux )
2180 if( !CV_IS_SEQ(seq) )
2181 CV_ERROR( !seq ? CV_StsNullPtr : CV_StsBadArg, "Bad input sequence" );
2186 if( seq->total <= 1 )
2189 elem_size = seq->elem_size;
2192 cvStartReadSeq( seq, &left, 0 );
2364 l = seq->total;
2368 l1 = seq->total;
2448 cvSeqSearch( CvSeq* seq, const void* _elem, CvCmpFunc cmp_func,
2461 if( !CV_IS_SEQ(seq) )
2462 CV_ERROR( !seq ? CV_StsNullPtr : CV_StsBadArg, "Bad input sequence" );
2467 elem_size = seq->elem_size;
2468 total = seq->total;
2476 cvStartReadSeq( seq, &reader, 0 );
2530 schar* ptr = cvGetSeqElem( seq, k );
2556 cvSeqInvert( CvSeq* seq )
2566 CV_CALL( cvStartReadSeq( seq, &left_reader, 0 ));
2567 CV_CALL( cvStartReadSeq( seq, &right_reader, 1 ));
2568 elem_size = seq->elem_size;
2569 count = seq->total >> 1;
2599 cvSeqPartition( const CvSeq* seq, CvMemStorage* storage, CvSeq** labels,
2619 if( !seq || !is_equal )
2623 storage = seq->storage;
2628 is_set = CV_IS_SET(seq);
2634 cvStartReadSeq( seq, &reader );
2639 for( i = 0; i < seq->total; i++ )
2645 CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
3356 icvSeqElemsClearFlags( CvSeq* seq, int offset, int clear_mask )
3365 if( !seq )
3368 elem_size = seq->elem_size;
3369 total = seq->total;
3374 CV_CALL( cvStartReadSeq( seq, &reader ));
3389 icvSeqFindNextElem( CvSeq* seq, int offset, int mask,
3401 if( !seq || !start_index )
3404 elem_size = seq->elem_size;
3405 total = seq->total;
3420 CV_CALL( cvStartReadSeq( seq, &reader ));
