1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* ---- includes ----------------------------------------------------------- */ 18 19 #include "b_BasicEm/Math.h" 20 #include "b_TensorEm/IdCluster2D.h" 21 22 /* ------------------------------------------------------------------------- */ 23 24 /* ========================================================================= */ 25 /* */ 26 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */ 27 /* */ 28 /* ========================================================================= */ 29 30 /* ------------------------------------------------------------------------- */ 31 32 /* ========================================================================= */ 33 /* */ 34 /* ---- \ghd{ constructor / destructor } ----------------------------------- */ 35 /* */ 36 /* ========================================================================= */ 37 38 /* ------------------------------------------------------------------------- */ 39 40 void bts_IdCluster2D_init( struct bbs_Context* cpA, 41 struct bts_IdCluster2D* ptrA ) 42 { 43 bts_Cluster2D_init( cpA, &ptrA->clusterE ); 44 bbs_Int16Arr_init( cpA, &ptrA->idArrE ); 45 } 46 47 /* ------------------------------------------------------------------------- */ 48 49 void bts_IdCluster2D_exit( struct bbs_Context* cpA, 50 struct bts_IdCluster2D* ptrA ) 51 { 52 bts_Cluster2D_exit( cpA, &ptrA->clusterE ); 53 bbs_Int16Arr_exit( cpA, &ptrA->idArrE ); 54 } 55 56 /* ------------------------------------------------------------------------- */ 57 58 /* ========================================================================= */ 59 /* */ 60 /* ---- \ghd{ operators } -------------------------------------------------- */ 61 /* */ 62 /* ========================================================================= */ 63 64 /* ------------------------------------------------------------------------- */ 65 66 void bts_IdCluster2D_copy( struct bbs_Context* cpA, 67 struct bts_IdCluster2D* ptrA, 68 const struct bts_IdCluster2D* srcPtrA ) 69 { 70 bts_Cluster2D_copy( cpA, &ptrA->clusterE, &srcPtrA->clusterE ); 71 bbs_Int16Arr_copy( cpA, &ptrA->idArrE, &srcPtrA->idArrE ); 72 } 73 74 /* ------------------------------------------------------------------------- */ 75 76 flag bts_IdCluster2D_equal( struct bbs_Context* cpA, 77 const struct bts_IdCluster2D* ptrA, 78 const struct bts_IdCluster2D* srcPtrA ) 79 { 80 if( !bts_Cluster2D_equal( cpA, &ptrA->clusterE, &srcPtrA->clusterE ) ) return FALSE; 81 if( !bbs_Int16Arr_equal( cpA, &ptrA->idArrE, &srcPtrA->idArrE ) ) return FALSE; 82 return TRUE; 83 } 84 85 /* ------------------------------------------------------------------------- */ 86 87 /* ========================================================================= */ 88 /* */ 89 /* ---- \ghd{ query functions } -------------------------------------------- */ 90 /* */ 91 /* ========================================================================= */ 92 93 /* ------------------------------------------------------------------------- */ 94 95 struct bts_Flt16Vec2D bts_IdCluster2D_center( struct bbs_Context* cpA, 96 const struct bts_IdCluster2D* ptrA ) 97 { 98 return bts_Cluster2D_center( cpA, &ptrA->clusterE ); 99 } 100 101 /* ------------------------------------------------------------------------- */ 102 103 struct bts_Int16Rect bts_IdCluster2D_boundingBox( struct bbs_Context* cpA, 104 const struct bts_IdCluster2D* ptrA ) 105 { 106 return bts_Cluster2D_boundingBox( cpA, &ptrA->clusterE ); 107 } 108 109 /* ------------------------------------------------------------------------- */ 110 111 /* ========================================================================= */ 112 /* */ 113 /* ---- \ghd{ modify functions } ------------------------------------------- */ 114 /* */ 115 /* ========================================================================= */ 116 117 /* ------------------------------------------------------------------------- */ 118 119 void bts_IdCluster2D_create( struct bbs_Context* cpA, 120 struct bts_IdCluster2D* ptrA, 121 uint32 sizeA, 122 struct bbs_MemSeg* mspA ) 123 { 124 if( bbs_Context_error( cpA ) ) return; 125 bts_Cluster2D_create( cpA, &ptrA->clusterE, sizeA, mspA ); 126 bbs_Int16Arr_create( cpA, &ptrA->idArrE, sizeA, mspA ); 127 } 128 129 /* ------------------------------------------------------------------------- */ 130 131 void bts_IdCluster2D_size( struct bbs_Context* cpA, 132 struct bts_IdCluster2D* ptrA, 133 uint32 sizeA ) 134 { 135 bts_Cluster2D_size( cpA, &ptrA->clusterE, sizeA ); 136 bbs_Int16Arr_size( cpA, &ptrA->idArrE, sizeA ); 137 } 138 139 /* ------------------------------------------------------------------------- */ 140 141 void bts_IdCluster2D_transform( struct bbs_Context* cpA, 142 struct bts_IdCluster2D* ptrA, 143 struct bts_Flt16Alt2D altA ) 144 { 145 bts_Cluster2D_transform( cpA, &ptrA->clusterE, altA ); 146 } 147 148 /* ------------------------------------------------------------------------- */ 149 150 void bts_IdCluster2D_copyTransform( struct bbs_Context* cpA, 151 struct bts_IdCluster2D* ptrA, 152 const struct bts_IdCluster2D* srcPtrA, 153 struct bts_Flt16Alt2D altA, 154 uint32 dstBbpA ) 155 { 156 bts_Cluster2D_copyTransform( cpA, &ptrA->clusterE, &srcPtrA->clusterE, altA, dstBbpA ); 157 bbs_Int16Arr_copy( cpA, &ptrA->idArrE, &srcPtrA->idArrE ); 158 } 159 160 /* ------------------------------------------------------------------------- */ 161 162 /* ========================================================================= */ 163 /* */ 164 /* ---- \ghd{ I/O } -------------------------------------------------------- */ 165 /* */ 166 /* ========================================================================= */ 167 168 /* ------------------------------------------------------------------------- */ 169 170 uint32 bts_IdCluster2D_memSize( struct bbs_Context* cpA, 171 const struct bts_IdCluster2D *ptrA ) 172 { 173 return bbs_SIZEOF16( uint32 ) 174 + bbs_SIZEOF16( uint32 ) /* version */ 175 + bts_Cluster2D_memSize( cpA, &ptrA->clusterE ) 176 + bbs_Int16Arr_memSize( cpA, &ptrA->idArrE ); 177 } 178 179 /* ------------------------------------------------------------------------- */ 180 181 uint32 bts_IdCluster2D_memWrite( struct bbs_Context* cpA, 182 const struct bts_IdCluster2D* ptrA, 183 uint16* memPtrA ) 184 { 185 uint32 memSizeL = bts_IdCluster2D_memSize( cpA, ptrA ); 186 memPtrA += bbs_memWrite32( &memSizeL, memPtrA ); 187 memPtrA += bbs_memWriteUInt32( bts_ID_CLUSTER2D_VERSION, memPtrA ); 188 memPtrA += bts_Cluster2D_memWrite( cpA, &ptrA->clusterE, memPtrA ); 189 memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->idArrE, memPtrA ); 190 return memSizeL; 191 } 192 193 /* ------------------------------------------------------------------------- */ 194 195 uint32 bts_IdCluster2D_memRead( struct bbs_Context* cpA, 196 struct bts_IdCluster2D* ptrA, 197 const uint16* memPtrA, 198 struct bbs_MemSeg* mspA ) 199 { 200 uint32 memSizeL; 201 uint32 versionL; 202 if( bbs_Context_error( cpA ) ) return 0; 203 memPtrA += bbs_memRead32( &memSizeL, memPtrA ); 204 memPtrA += bbs_memReadVersion32( cpA, &versionL, bts_ID_CLUSTER2D_VERSION, memPtrA ); 205 memPtrA += bts_Cluster2D_memRead( cpA, &ptrA->clusterE, memPtrA, mspA ); 206 memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->idArrE, memPtrA, mspA ); 207 if( memSizeL != bts_IdCluster2D_memSize( cpA, ptrA ) ) 208 { 209 bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bts_IdCluster2D_memRead( const struct bts_IdCluster2D* ptrA, const void* memPtrA ):\n" 210 "size mismatch" ); 211 return 0; 212 } 213 return memSizeL; 214 } 215 216 /* ------------------------------------------------------------------------- */ 217 218 /* ========================================================================= */ 219 /* */ 220 /* ---- \ghd{ exec functions } --------------------------------------------- */ 221 /* */ 222 /* ========================================================================= */ 223 224 /* ------------------------------------------------------------------------- */ 225 226 void bts_IdCluster2D_convertToEqivalentClusters( struct bbs_Context* cpA, 227 const struct bts_IdCluster2D* inCluster1PtrA, 228 const struct bts_IdCluster2D* inCluster2PtrA, 229 struct bts_Cluster2D* outCluster1PtrA, 230 struct bts_Cluster2D* outCluster2PtrA ) 231 { 232 uint32 iL, jL; 233 uint32 countL = 0; 234 235 uint32 size1L = inCluster1PtrA->clusterE.sizeE; 236 uint32 size2L = inCluster2PtrA->clusterE.sizeE; 237 238 const int16* idArr1L = inCluster1PtrA->idArrE.arrPtrE; 239 const int16* idArr2L = inCluster2PtrA->idArrE.arrPtrE; 240 241 const struct bts_Int16Vec2D* srcVecArr1E = inCluster1PtrA->clusterE.vecArrE; 242 const struct bts_Int16Vec2D* srcVecArr2E = inCluster2PtrA->clusterE.vecArrE; 243 244 struct bts_Int16Vec2D* dstVecArr1E = outCluster1PtrA->vecArrE; 245 struct bts_Int16Vec2D* dstVecArr2E = outCluster2PtrA->vecArrE; 246 247 uint32 maxOutSizeL = bbs_min( outCluster1PtrA->allocatedSizeE, outCluster2PtrA->allocatedSizeE ); 248 bts_Cluster2D_size( cpA, outCluster1PtrA, maxOutSizeL ); 249 bts_Cluster2D_size( cpA, outCluster2PtrA, maxOutSizeL ); 250 251 for( iL = 0; iL < size1L; iL++ ) 252 { 253 int32 idL = idArr1L[ iL ]; 254 if( idL >= 0 ) 255 { 256 for( jL = 0; jL < size2L; jL++ ) 257 { 258 if( idL == idArr2L[ jL ] ) break; 259 } 260 261 if( jL < size2L ) 262 { 263 if( countL == maxOutSizeL ) 264 { 265 bbs_ERROR0( "void bts_IdCluster2D_convertToEqivalentClusters( .... ):\n" 266 "Destination clusters are insufficiently allocated" ); 267 return; 268 } 269 270 dstVecArr1E[ countL ] = srcVecArr1E[ iL ]; 271 dstVecArr2E[ countL ] = srcVecArr2E[ jL ]; 272 countL++; 273 } 274 } 275 } 276 277 bts_Cluster2D_size( cpA, outCluster1PtrA, countL ); 278 bts_Cluster2D_size( cpA, outCluster2PtrA, countL ); 279 280 outCluster1PtrA->bbpE = inCluster1PtrA->clusterE.bbpE; 281 outCluster2PtrA->bbpE = inCluster2PtrA->clusterE.bbpE; 282 } 283 284 /* ------------------------------------------------------------------------- */ 285 286 struct bts_Flt16Alt2D bts_IdCluster2D_alt( struct bbs_Context* cpA, 287 const struct bts_IdCluster2D* srcPtrA, 288 struct bts_IdCluster2D* dstPtrA, 289 enum bts_AltType altTypeA, 290 struct bts_Cluster2D* tmpPtr1A, /* temporary cluster 1 */ 291 struct bts_Cluster2D* tmpPtr2A ) /* temporary cluster 2 */ 292 { 293 bts_IdCluster2D_convertToEqivalentClusters( cpA, srcPtrA, dstPtrA, tmpPtr1A, tmpPtr2A ); 294 return bts_Cluster2D_alt( cpA, tmpPtr1A, tmpPtr2A, altTypeA ); 295 } 296 297 /* ------------------------------------------------------------------------- */ 298 299 /* ========================================================================= */ 300 301 302
