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 
bts_IdCluster2D_init(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA)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 
bts_IdCluster2D_exit(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA)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 
bts_IdCluster2D_copy(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,const struct bts_IdCluster2D * srcPtrA)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 
bts_IdCluster2D_equal(struct bbs_Context * cpA,const struct bts_IdCluster2D * ptrA,const struct bts_IdCluster2D * srcPtrA)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 
bts_IdCluster2D_center(struct bbs_Context * cpA,const struct bts_IdCluster2D * ptrA)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 
bts_IdCluster2D_boundingBox(struct bbs_Context * cpA,const struct bts_IdCluster2D * ptrA)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 
bts_IdCluster2D_create(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,uint32 sizeA,struct bbs_MemSeg * mspA)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 
bts_IdCluster2D_size(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,uint32 sizeA)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 
bts_IdCluster2D_transform(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,struct bts_Flt16Alt2D altA)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 
bts_IdCluster2D_copyTransform(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,const struct bts_IdCluster2D * srcPtrA,struct bts_Flt16Alt2D altA,uint32 dstBbpA)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 
bts_IdCluster2D_memSize(struct bbs_Context * cpA,const struct bts_IdCluster2D * ptrA)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 
bts_IdCluster2D_memWrite(struct bbs_Context * cpA,const struct bts_IdCluster2D * ptrA,uint16 * memPtrA)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 
bts_IdCluster2D_memRead(struct bbs_Context * cpA,struct bts_IdCluster2D * ptrA,const uint16 * memPtrA,struct bbs_MemSeg * mspA)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 
bts_IdCluster2D_convertToEqivalentClusters(struct bbs_Context * cpA,const struct bts_IdCluster2D * inCluster1PtrA,const struct bts_IdCluster2D * inCluster2PtrA,struct bts_Cluster2D * outCluster1PtrA,struct bts_Cluster2D * outCluster2PtrA)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 
bts_IdCluster2D_alt(struct bbs_Context * cpA,const struct bts_IdCluster2D * srcPtrA,struct bts_IdCluster2D * dstPtrA,enum bts_AltType altTypeA,struct bts_Cluster2D * tmpPtr1A,struct bts_Cluster2D * tmpPtr2A)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