weixin_34255793

[22] 计算几何图形包围盒与包围球的算法

计算几何图形包围盒的算法

  1 bool                        YfCalculateSurroundBoxSize
  2 (
  3     const YsGraphDesc&      graphDesc,
  4     YsVector&               vMin,
  5     YsVector&               vMax
  6 )
  7 {
  8     switch (graphDesc.graphType)
  9     {
 10     case YE_GRAPH_PLANE:
 11         {
 12             if (graphDesc.slices < 2 || graphDesc.stacks < 2)
 13             {
 14                 return false;
 15             }   
 16             vMin = YsVector(0.0f, graphDesc.height - 0.5f, 0.0f);
 17             vMax = YsVector(graphDesc.width, graphDesc.height + 0.5f, graphDesc.length);
 18             if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
 19             {
 20                 vMin.x -= graphDesc.width * 0.5f;
 21                 vMin.z -= graphDesc.length * 0.5f;
 22                 vMax.x -= graphDesc.width * 0.5f;
 23                 vMax.z -= graphDesc.length * 0.5f;
 24             }
 25         }
 26         break;
 27 
 28     case YE_GRAPH_BOX:
 29         {
 30             vMin = YsVector(0.0f, 0.0f, 0.0f);
 31             vMax = YsVector(graphDesc.extentX, graphDesc.extentY, graphDesc.extentZ);
 32 
 33             YsVector3 vOriginOffset = -vMax * 0.5f;
 34             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 35             {
 36                 vOriginOffset.y = -graphDesc.extentY;
 37             }
 38             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 39             {
 40                 vOriginOffset.y = 0.0f;
 41             }
 42             vMin += vOriginOffset;
 43             vMax += vOriginOffset;
 44         }
 45         break;
 46 
 47     case YE_GRAPH_SPHERE:
 48         {
 49             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 50             {
 51                 return false;
 52             }
 53             vMin = YsVector(-graphDesc.radius);
 54             vMax = YsVector(graphDesc.radius);
 55             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 56             {
 57                 vMin.y -= graphDesc.radius;
 58                 vMax.y -= graphDesc.radius;
 59             }
 60             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 61             {
 62                 vMin.y += graphDesc.radius;
 63                 vMax.y += graphDesc.radius;
 64             }
 65         }
 66         break;
 67 
 68     case YE_GRAPH_DRUM:
 69         {
 70             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 71             {
 72                 return false;
 73             }
 74             vMin = YsVector(-graphDesc.radius);
 75             vMax = YsVector(graphDesc.radius);
 76 
 77             vMin.x -= graphDesc.assistRadius;
 78             vMin.z -= graphDesc.assistRadius;
 79             vMax.x += graphDesc.assistRadius;
 80             vMax.z += graphDesc.assistRadius;
 81 
 82             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 83             {
 84                 vMin.y -= graphDesc.radius;
 85                 vMax.y -= graphDesc.radius;
 86             }
 87             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 88             {
 89                 vMin.y += graphDesc.radius;
 90                 vMax.y += graphDesc.radius;
 91             }
 92         }
 93         break;    
 94     
 95     case YE_GRAPH_HEMISPHERE:
 96         {
 97             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 98             {
 99                 return false;
100             }
101             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
102             vMax = YsVector(graphDesc.radius);
103             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
104             {
105                 vMin.y -= graphDesc.radius;
106                 vMax.y -= graphDesc.radius;
107             }
108             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
109             {
110                 vMin.y += graphDesc.radius;
111                 vMax.y += graphDesc.radius;
112             }
113         }
114         break;
115 
116     case YE_GRAPH_CONE:
117         {
118             if (graphDesc.slices < 2)
119             {
120                 return false;
121             }
122             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
123             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
124             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
125             {
126                 vMin.y -= graphDesc.height;
127                 vMax.y -= graphDesc.height;
128             }
129             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
130             {
131                 vMin.y -= graphDesc.height * 0.5f;
132                 vMax.y -= graphDesc.height * 0.5f;
133             }
134         }
135         break;
136 
137     case YE_GRAPH_CYLINDER:
138         { 
139             if (graphDesc.slices < 2)
140             {
141                 return false;
142             }
143 
144             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
145             vMin = YsVector(-radius, 0.0f, -radius);
146             vMax = YsVector(radius, graphDesc.height, radius);
147             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
148             {
149                 vMin.y -= graphDesc.height;
150                 vMax.y -= graphDesc.height;
151             }
152             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
153             {
154                 vMin.y -= graphDesc.height * 0.5f;
155                 vMax.y -= graphDesc.height * 0.5f;
156             }
157         }
158         break;
159 
160     case YE_GRAPH_CAPSULE:
161         {
162             Yuint halfStacks = graphDesc.stacks / 2;
163             if (graphDesc.slices < 2 || halfStacks < 2)
164             {
165                 return false;
166             }
167             vMin = YsVector(-graphDesc.radius, -graphDesc.radius - graphDesc.height*0.5f, -graphDesc.radius);
168             vMax = YsVector(graphDesc.radius,  graphDesc.radius  + graphDesc.height*0.5f, graphDesc.radius);
169             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
170             {
171                 vMin.y -= graphDesc.radius + graphDesc.height;
172                 vMax.y -= graphDesc.radius + graphDesc.height;
173             }
174             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
175             {
176                 vMin.y += graphDesc.radius + graphDesc.height;
177                 vMax.y += graphDesc.radius + graphDesc.height;
178             }
179         }
180         break;
181 
182     case YE_GRAPH_PYRAMID:
183         {
184             vMin = YsVector(0.0f, 0.0f, 0.0f);
185             vMax = YsVector(graphDesc.width, graphDesc.height, graphDesc.length);
186 
187             YsVector3 vOriginOffset(-graphDesc.width / 2, -graphDesc.height / 2, -graphDesc.length / 2);
188             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
189             {
190                 vOriginOffset.y = -graphDesc.height;
191             }
192             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
193             {
194                 vOriginOffset.y = 0.0f;
195             }
196             vMin += vOriginOffset;
197             vMax += vOriginOffset;
198         }
199         break;
200 
201     case YE_GRAPH_ROUND:
202         {
203             if (graphDesc.slices < 3)
204             {
205                 return false;
206             }
207             vMin = YsVector(-graphDesc.radius, graphDesc.height - 0.5f, -graphDesc.radius);
208             vMax = YsVector(graphDesc.radius,  graphDesc.height + 0.5f, graphDesc.radius);
209         }
210         break;
211 
212     case YE_GRAPH_RING:
213         {
214             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
215             {
216                 return false;
217             }
218 
219             Yreal halfHeight = graphDesc.height * 0.5f;
220             vMin = YsVector(-graphDesc.radius - graphDesc.assistRadius, 
221                             -halfHeight, 
222                             -graphDesc.radius - graphDesc.assistRadius);
223             vMax = YsVector(graphDesc.radius + graphDesc.assistRadius, 
224                             halfHeight, 
225                             graphDesc.radius + graphDesc.assistRadius);
226 
227             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
228             {
229                 vMin.y -= halfHeight;
230                 vMax.y -= halfHeight;
231             }
232             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
233             {
234                 vMin.y += halfHeight;
235                 vMax.y += halfHeight;
236             }
237         }
238         break;
239 
240     case YE_GRAPH_PIPE:
241         {
242             if (graphDesc.slices < 2)
243             {
244                 return false;
245             }
246             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
247             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
248             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
249             {
250                 vMin.y -= graphDesc.height;
251                 vMax.y -= graphDesc.height;
252             }
253             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
254             {
255                 vMin.y -= graphDesc.height * 0.5f;
256                 vMax.y -= graphDesc.height * 0.5f;
257             }
258         }
259         break;
260 
261     case YE_GRAPH_WEDGE:
262         {
263             vMin = YsVector(0.0f, 0.0f, 0.0f);
264             vMax = YsVector(graphDesc.width, graphDesc.height, graphDesc.length);
265 
266             YsVector3 vOriginOffset(-graphDesc.width / 2, -graphDesc.height / 2, -graphDesc.length / 2);
267             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
268             {
269                 vOriginOffset.y = -graphDesc.height;
270             }
271             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
272             {
273                 vOriginOffset.y = 0.0f;
274             }
275             vMin += vOriginOffset;
276             vMax += vOriginOffset;
277         }
278         break;
279 
280     case YE_GRAPH_FAN:
281         {
282             if (graphDesc.degree < 0 || graphDesc.degree > 360)
283             {
284                 return false;
285             }
286             if (graphDesc.slices < 2)
287             {
288                 return false;
289             }
290             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
291             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
292             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
293             {
294                 vMin.y -= graphDesc.height;
295                 vMax.y -= graphDesc.height;
296             }
297             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
298             {
299                 vMin.y -= graphDesc.height * 0.5f;
300                 vMax.y -= graphDesc.height * 0.5f;
301             }
302 
303             Yreal radian = YD_DEGREE_TO_RADIAN(graphDesc.degree);
304             if (graphDesc.degree < 90)
305             {
306                 vMin.x = 0.0f;
307                 vMax.x = graphDesc.radius * yf_sin(radian);
308                 vMin.z = 0.0f;
309             }
310             else if (graphDesc.degree < 180)
311             {
312                 vMin.x = 0.0f;
313                 vMin.z = graphDesc.radius * yf_cos(radian);
314             }
315             else if (graphDesc.degree < 270)
316             {
317                 vMin.x = graphDesc.radius * yf_sin(radian);
318             }
319         }
320         break;
321 
322     case YE_GRAPH_ARC:
323         {
324             if (graphDesc.degree < 0 || graphDesc.degree > 180)
325             {
326                 return false;
327             }
328             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
329             {
330                 return false;
331             }
332 
333             Yreal radian = YD_DEGREE_TO_RADIAN(graphDesc.degree);
334             Yreal radius;
335             if (graphDesc.degree > 90)
336             {
337                 radius = graphDesc.radius;
338             }
339             else
340             {
341                 radius = graphDesc.radius * yf_sin(radian);
342             }
343 
344             vMin = YsVector(-radius, -graphDesc.radius, -radius);
345             vMax = YsVector(radius,  graphDesc.radius,  radius);
346             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
347             {
348                 vMin.y -= graphDesc.radius;
349                 vMax.y -= graphDesc.radius;
350             }
351             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
352             {
353                 vMin.y += graphDesc.radius;
354                 vMax.y += graphDesc.radius;
355             }
356 
357             Yreal arcHeight = graphDesc.radius * (1 - yf_cos(radian));
358             vMin.y += graphDesc.radius * 2 - arcHeight;
359         }
360         break;
361 
362     case YE_GRAPH_GEARWHEEL:
363         {
364             if (graphDesc.slices < 3)
365             {
366                 return false;
367             }
368             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
369             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
370             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
371             {
372                 vMin.y -= graphDesc.height;
373                 vMax.y -= graphDesc.height;
374             }
375             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
376             {
377                 vMin.y -= graphDesc.height * 0.5f;
378                 vMax.y -= graphDesc.height * 0.5f;
379             }
380         }
381         break;
382 
383     case YE_GRAPH_STAR:
384         {
385             if (graphDesc.slices < 3)
386             {
387                 return false;
388             }
389             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
390             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
391             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
392             {
393                 vMin.y -= graphDesc.height;
394                 vMax.y -= graphDesc.height;
395             }
396             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
397             {
398                 vMin.y -= graphDesc.height * 0.5f;
399                 vMax.y -= graphDesc.height * 0.5f;
400             }
401         }
402         break;
403 
404     case YE_GRAPH_SPIRE:
405         {
406             if (graphDesc.stacks < 1 || graphDesc.slices < 3)
407             {
408                 return false;
409             }
410 
411             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
412             vMin = YsVector(-radius, 0.0f, -radius);
413             vMax = YsVector(radius, graphDesc.height, radius);
414             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
415             {
416                 vMin.y -= graphDesc.height;
417                 vMax.y -= graphDesc.height;
418             }
419             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
420             {
421                 vMin.y -= graphDesc.height * 0.5f;
422                 vMax.y -= graphDesc.height * 0.5f;
423             }
424         }
425         break;
426 
427     case YE_GRAPH_STAIRS:
428         {
429             if (graphDesc.stacks < 1)
430             {
431                 return false;
432             }
433             vMin = YsVector(0.0f, 0.0f, 0.0f);
434             vMax = YsVector(graphDesc.extentX, graphDesc.extentY, graphDesc.extentZ);
435 
436             YsVector3 vOriginOffset = -vMax * 0.5f;
437             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
438             {
439                 vOriginOffset.y = -graphDesc.extentY;
440             }
441             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
442             {
443                 vOriginOffset.y = 0.0f;
444             }
445             vMin += vOriginOffset;
446             vMax += vOriginOffset;
447         }
448         break;
449 
450     case YE_GRAPH_SPIRAL_STAIRS:
451         {
452             if (graphDesc.stacks < 1 || graphDesc.slices < 3)
453             {
454                 return false;
455             }
456 
457             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
458             vMin = YsVector(-radius, 0.0f, -radius);
459             vMax = YsVector(radius, graphDesc.height, radius);
460             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
461             {
462                 vMin.y -= graphDesc.height;
463                 vMax.y -= graphDesc.height;
464             }
465             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
466             {
467                 vMin.y -= graphDesc.height * 0.5f;
468                 vMax.y -= graphDesc.height * 0.5f;
469             }
470         }
471         break;
472 
473     default:
474         {
475             return false;
476         }
477         break;
478     }
479 
480     return true;
481 }

计算几何图形包围球的算法

  1 // 计算一个规则图形的包围球大小
  2 bool                        YfCalculateSurroundSphereSize
  3 (
  4     const YsGraphDesc&      graphDesc,
  5     OUT YsVector&           vCenter,
  6     OUT Yreal&              fRadius
  7 )
  8 {
  9     switch (graphDesc.graphType)
 10     {
 11     case YE_GRAPH_PLANE:
 12         {
 13             if (graphDesc.slices < 2 || graphDesc.stacks < 2)
 14             {
 15                 return false;
 16             }   
 17 
 18             fRadius = yf_sqrt(graphDesc.width * graphDesc.width + 
 19                 graphDesc.length * graphDesc.length) / 2;
 20 
 21             if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
 22             {
 23                 vCenter = YsVector(0.0f, graphDesc.height, 0.0f);
 24             }
 25             else
 26             {
 27                 vCenter = YsVector(graphDesc.width / 2, graphDesc.height, graphDesc.length / 2);
 28             }
 29         }
 30         break;
 31 
 32     case YE_GRAPH_BOX:
 33         {
 34             fRadius = yf_sqrt(graphDesc.extentX * graphDesc.extentX + 
 35                 graphDesc.extentY * graphDesc.extentY + 
 36                 graphDesc.extentZ * graphDesc.extentZ ) / 2;
 37 
 38             vCenter = YsVector(0.0f, 0.0f, 0.0f);
 39             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 40             {
 41                 vCenter.y = -graphDesc.extentY / 2;
 42             }
 43             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 44             {
 45                 vCenter.y = graphDesc.extentY / 2;
 46             }
 47         }
 48         break;
 49 
 50     case YE_GRAPH_SPHERE:
 51         {
 52             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 53             {
 54                 return false;
 55             }
 56             fRadius = graphDesc.radius;
 57 
 58             vCenter = YsVector(0.0f, 0.0f, 0.0f);
 59             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 60             {
 61                 vCenter.y -= graphDesc.radius;
 62             }
 63             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 64             {
 65                 vCenter.y += graphDesc.radius;
 66             }
 67         }
 68         break;
 69 
 70     case YE_GRAPH_HEMISPHERE:
 71         {
 72             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 73             {
 74                 return false;
 75             }
 76             fRadius = graphDesc.radius;
 77 
 78             vCenter = YsVector(0.0f, 0.0f, 0.0f);
 79             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
 80             {
 81                 vCenter.y -= graphDesc.radius;
 82             }
 83             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
 84             {
 85                 vCenter.y += graphDesc.radius;
 86             }
 87         }
 88         break;
 89 
 90     case YE_GRAPH_DRUM:
 91         {
 92             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
 93             {
 94                 return false;
 95             }
 96             fRadius = graphDesc.radius + graphDesc.assistRadius;
 97 
 98             vCenter = YsVector(0.0f, 0.0f, 0.0f);
 99             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
100             {
101                 vCenter.y -= graphDesc.radius;
102             }
103             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
104             {
105                 vCenter.y += graphDesc.radius;
106             }
107         }
108         break;
109 
110     case YE_GRAPH_CONE:
111         {
112             if (graphDesc.slices < 2)
113             {
114                 return false;
115             }
116 
117             if (graphDesc.height < graphDesc.radius)
118             {
119                 fRadius = graphDesc.radius;
120                 vCenter = YsVector(0.0f, 0.0f, 0.0f);
121             }
122             else
123             {
124                 Yreal h = (graphDesc.height*graphDesc.height - graphDesc.radius*graphDesc.radius) / 
125                     2 / graphDesc.height;
126                 fRadius = graphDesc.height - h;
127                 vCenter = YsVector(0.0f, h, 0.0f);
128             }
129 
130             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
131             {
132                 vCenter.y -= graphDesc.height;
133             }
134             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
135             {
136                 vCenter.y -= graphDesc.height * 0.5f;
137             }
138         }
139         break;
140 
141     case YE_GRAPH_CYLINDER:
142         { 
143             if (graphDesc.slices < 2)
144             {
145                 return false;
146             }
147 
148             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
149 
150             fRadius = yf_sqrt(radius*radius + graphDesc.height*graphDesc.height/4);
151 
152             vCenter = YsVector(0.0f, 0.0f, 0.0f);
153             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
154             {
155                 vCenter.y -= graphDesc.height / 2;
156             }
157             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
158             {
159                 vCenter.y += graphDesc.height / 2;
160             }
161         }
162         break;
163 
164     case YE_GRAPH_CAPSULE:
165         {
166             Yuint halfStacks = graphDesc.stacks / 2;
167             if (graphDesc.slices < 2 || halfStacks < 2)
168             {
169                 return false;
170             }
171 
172             fRadius = graphDesc.radius + graphDesc.height/2;
173 
174             vCenter = YsVector(0.0f, 0.0f, 0.0f);
175             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
176             {
177                 vCenter.y -= fRadius;
178             }
179             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
180             {
181                 vCenter.y += fRadius;
182             }
183         }
184         break;
185 
186     case YE_GRAPH_PYRAMID:
187         {
188             Yreal radius = yf_sqrt(graphDesc.width*graphDesc.width + graphDesc.length*graphDesc.length) / 2;
189             if (graphDesc.height < radius)
190             {
191                 fRadius = radius;
192                 vCenter = YsVector(0.0f, 0.0f, 0.0f);
193             }
194             else
195             {
196                 Yreal h = (graphDesc.height*graphDesc.height - radius*radius) / 
197                     2 / graphDesc.height;
198                 fRadius = graphDesc.height - h;
199                 vCenter = YsVector(0.0f, h, 0.0f);
200             }
201 
202             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
203             {
204                 vCenter.y -= graphDesc.height;
205             }
206             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
207             {
208                 vCenter.y -= graphDesc.height * 0.5f;
209             }
210         }
211         break;
212 
213     case YE_GRAPH_ROUND:
214         {
215             if (graphDesc.slices < 3)
216             {
217                 return false;
218             }
219             fRadius = graphDesc.radius;
220             vCenter = YsVector(0, graphDesc.height, 0);
221         }
222         break;
223 
224     case YE_GRAPH_RING:
225         {
226             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
227             {
228                 return false;
229             }
230 
231             fRadius = graphDesc.radius + graphDesc.assistRadius;
232 
233             vCenter = YsVector(0.0f, 0.0f, 0.0f);
234             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
235             {
236                 vCenter.y -= graphDesc.height / 2;
237             }
238             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
239             {
240                 vCenter.y += graphDesc.height / 2;
241             }
242         }
243         break;
244 
245     case YE_GRAPH_PIPE:
246         {
247             if (graphDesc.slices < 2)
248             {
249                 return false;
250             }
251 
252             fRadius = yf_sqrt(graphDesc.radius*graphDesc.radius + graphDesc.height*graphDesc.height/4);
253 
254             vCenter = YsVector(0.0f, 0.0f, 0.0f);
255             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
256             {
257                 vCenter.y -= graphDesc.height / 2;
258             }
259             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
260             {
261                 vCenter.y += graphDesc.height / 2;
262             }
263         }
264         break;
265 
266     case YE_GRAPH_GEARWHEEL:
267         {
268             if (graphDesc.slices < 3)
269             {
270                 return false;
271             }
272             fRadius = yf_sqrt(graphDesc.radius*graphDesc.radius + graphDesc.height*graphDesc.height/4);
273 
274             vCenter = YsVector(0.0f, 0.0f, 0.0f);
275             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
276             {
277                 vCenter.y -= graphDesc.height / 2;
278             }
279             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
280             {
281                 vCenter.y += graphDesc.height / 2;
282             }
283         }
284         break;
285 
286     case YE_GRAPH_STAR:
287         {
288             if (graphDesc.slices < 3)
289             {
290                 return false;
291             }
292 
293             if (graphDesc.height < graphDesc.radius)
294             {
295                 fRadius = graphDesc.radius;
296                 vCenter = YsVector(0.0f, 0.0f, 0.0f);
297             }
298             else
299             {
300                 Yreal h = (graphDesc.height*graphDesc.height - graphDesc.radius*graphDesc.radius) / 
301                     2 / graphDesc.height;
302                 fRadius = graphDesc.height - h;
303                 vCenter = YsVector(0.0f, h, 0.0f);
304             }
305 
306             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
307             {
308                 vCenter.y -= graphDesc.height;
309             }
310             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
311             {
312                 vCenter.y -= graphDesc.height * 0.5f;
313             }
314         }
315         break;
316 
317     case YE_GRAPH_SPIRE:
318         {
319             if (graphDesc.stacks < 1 || graphDesc.slices < 3)
320             {
321                 return false;
322             }
323 
324             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
325 
326             fRadius = yf_sqrt(radius*radius + graphDesc.height*graphDesc.height/4);
327 
328             vCenter = YsVector(0.0f, 0.0f, 0.0f);
329             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
330             {
331                 vCenter.y -= graphDesc.height / 2;
332             }
333             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
334             {
335                 vCenter.y += graphDesc.height / 2;
336             }
337         }
338         break;
339 
340     case YE_GRAPH_STAIRS:
341         {
342             if (graphDesc.stacks < 1)
343             {
344                 return false;
345             }
346 
347             fRadius = yf_sqrt(graphDesc.extentX * graphDesc.extentX + 
348                 graphDesc.extentY * graphDesc.extentY + 
349                 graphDesc.extentZ * graphDesc.extentZ ) / 2;
350 
351             vCenter = YsVector(0.0f, 0.0f, 0.0f);
352             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
353             {
354                 vCenter.y = -graphDesc.extentY / 2;
355             }
356             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
357             {
358                 vCenter.y = graphDesc.extentY / 2;
359             }
360         }
361         break;
362 
363     case YE_GRAPH_SPIRAL_STAIRS:
364         {
365             if (graphDesc.stacks < 1 || graphDesc.slices < 3)
366             {
367                 return false;
368             }
369 
370             Yreal radius = (graphDesc.radius > graphDesc.assistRadius) ? graphDesc.radius : graphDesc.assistRadius;
371 
372             fRadius = yf_sqrt(radius*radius + graphDesc.height*graphDesc.height/4);
373 
374             vCenter = YsVector(0.0f, 0.0f, 0.0f);
375             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
376             {
377                 vCenter.y -= graphDesc.height / 2;
378             }
379             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
380             {
381                 vCenter.y += graphDesc.height / 2;
382             }
383         }
384         break;
385 
386     case YE_GRAPH_WEDGE:
387         {
388             fRadius = yf_sqrt(graphDesc.extentX * graphDesc.extentX + 
389                 graphDesc.extentY * graphDesc.extentY + 
390                 graphDesc.extentZ * graphDesc.extentZ ) / 2;
391 
392             vCenter = YsVector(0.0f, 0.0f, 0.0f);
393             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
394             {
395                 vCenter.y = -graphDesc.extentY / 2;
396             }
397             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
398             {
399                 vCenter.y = graphDesc.extentY / 2;
400             }
401         }
402         break;
403 
404     case YE_GRAPH_FAN:
405         {
406             if (graphDesc.degree < 0 || graphDesc.degree > 360)
407             {
408                 return false;
409             }
410             if (graphDesc.slices < 2)
411             {
412                 return false;
413             }
414             YsVector vMin, vMax;
415             vMin = YsVector(-graphDesc.radius, 0.0f, -graphDesc.radius);
416             vMax = YsVector(graphDesc.radius, graphDesc.height, graphDesc.radius);
417             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
418             {
419                 vMin.y -= graphDesc.height;
420                 vMax.y -= graphDesc.height;
421             }
422             else if (graphDesc.originPose == YE_ORIGIN_POSE_CENTER)
423             {
424                 vMin.y -= graphDesc.height * 0.5f;
425                 vMax.y -= graphDesc.height * 0.5f;
426             }
427 
428             Yreal radian = YD_DEGREE_TO_RADIAN(graphDesc.degree);
429             if (graphDesc.degree < 90)
430             {
431                 vMin.x = 0.0f;
432                 vMax.x = graphDesc.radius * yf_sin(radian);
433                 vMin.z = 0.0f;
434             }
435             else if (graphDesc.degree < 180)
436             {
437                 vMin.x = 0.0f;
438                 vMin.z = graphDesc.radius * yf_cos(radian);
439             }
440             else if (graphDesc.degree < 270)
441             {
442                 vMin.x = graphDesc.radius * yf_sin(radian);
443             }
444             vCenter = (vMax + vMin) / 2;
445             YsVector vDis = vMax - vMin;
446             fRadius = vDis.Magnitude() / 2;
447         }
448         break;
449 
450     case YE_GRAPH_ARC:
451         {
452             if (graphDesc.degree < 0 || graphDesc.degree > 180)
453             {
454                 return false;
455             }
456             if (graphDesc.slices < 2 || graphDesc.stacks < 3)
457             {
458                 return false;
459             }
460 
461             Yreal radian = YD_DEGREE_TO_RADIAN(graphDesc.degree);
462 
463             if (graphDesc.degree > 90)
464             {
465                 fRadius = graphDesc.radius;
466                 vCenter = YsVector(0.0f, 0.0f, 0.0f);
467             }
468             else
469             {
470                 fRadius = graphDesc.radius * yf_sin(radian);
471                 vCenter = YsVector(0.0f, graphDesc.radius * yf_cos(radian), 0.0f);
472             }
473 
474             if (graphDesc.originPose == YE_ORIGIN_POSE_TOP)
475             {
476                 vCenter.y -= graphDesc.radius;
477             }
478             else if (graphDesc.originPose == YE_ORIGIN_POSE_BOTTOM)
479             {
480                 vCenter.y += graphDesc.radius;
481             }
482         }
483         break;
484 
485     default:
486         {
487             return false;
488         }
489         break;
490     }
491 
492     return true;
493 }

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
芦花鞋一四许叶晗
又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
关于沟通这件事，项目经理不需要每次都面对面进行流程大师兄
很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
铭刻于星（四十二）随风至
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说造命者说
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
2020-01-25 晴岚85
郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
想家爆米花机
也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
【iOS】MVC设计模式 Magnetic_h ios mvc 设计模式 objective-c 学习 ui
MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
一百九十四章. 自相矛盾巨木擎天
唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
UI学习——cell的复用和自定义cell Magnetic_h ui 学习
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
地推话术，如何应对地推过程中家长的拒绝校师学
相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
C语言如何定义宏函数？小九格物 c语言
在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
小丽成长记（四十三）玲玲54321
小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
学点心理知识，呵护孩子健康静候花开_7090
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断尐尐呅
结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
瑶池防线谜影梦蝶
冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
爬山后遗症璃绛
爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
JVM StackMapTable 属性的作用及理解 lijingyao8206 jvm 字节码 Class文件 StackMapTable
在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
回调函数调用方法百合不是茶 java
最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记记录一下代码很简单: MainDemo :调用方法得到方法的返回结果
[时间机器]制造时间机器需要一些材料 comsci 制造
根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质和材料... 甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......
开口埋怨不如闭口做事邓集海邓集海做人做事工作
“开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。　　　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。　　　　
jQuery插件开发全解析，类级别与对象级别开发 IT独行者 jquery 开发插件　函数
jQuery插件的开发包括两种：一种是类级别的插件开发，即给 jQuery添加新的全局函数，相当于给 jQuery类本身添加方法。 jQuery的全局函数就是属于 jQuery命名空间的函数，另一种是对象级别的插件开发，即给 jQuery对象添加方法。下面就两种函数的开发做详细的说明。 1 、类级别的插件开发类级别的插件开发最直接的理解就是给jQuer
Rome解析Rss 413277409 Rome解析Rss
import java.net.URL; import java.util.List; import org.junit.Test; import com.sun.syndication.feed.synd.SyndCategory; import com.sun.syndication.feed.synd.S
RSA加密解密无量加密解密 rsa
RSA加密解密代码代码有待整理 package com.tongbanjie.commons.util; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerat
linux 软件安装遇到的问题 aichenglong linux 遇到的问题 ftp
1 ftp配置中遇到的问题 500 OOPS: cannot change directory 出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了修改方法:1 修改/etc/selinux/config 中SELINUX=disabled 2 source /etc
面试心得 alafqq 面试
最近面试了好几家公司。记录下；支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败；阿里金融，面试官人也挺和善，只不过我让他吐血了。。。由于印象比较深，记录下； 1，自我介绍 2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型） 3，什么是包装类，包装类的优点； 4，平时看过什么书？NND，什么书都没看过。。照样
java的多态性探讨百合不是茶 java
java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况 //package 1; class A{ public void test(){ System.out.println("A"); } } class D extends A{ public void test(){ S
网络编程基础篇之JavaScript-学习笔记 bijian1013 JavaScript
1.documentWrite <html> <head> <script language="JavaScript"> document.write("这是电脑网络学校"); document.close(); </script> </h
探索JUnit4扩展：深入Rule bijian1013 JUnit Rule 单元测试
本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
[CSS]CSS浮动十五条规则 bit1129 css
这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。 1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景 bit1129 partition
0.Kafka服务器配置 3个broker 1个topic，6个partition，副本因子是2 2个consumer，每个consumer三个线程并发读取 1. Producer package kafka.examples.multibrokers.producers; import java.util.Properties; import java.util.
zabbix_agentd.conf配置文件详解 ronin47 zabbix 配置文件
Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]，或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
java--19.用矩阵求Fibonacci数列的第N项 bylijinnan fibonacci
参考了网上的思路，写了个Java版的： public class Fibonacci { final static int[] A={1,1,1,0}; public static void main(String[] args) { int n=7; for(int i=0;i<=n;i++){ int f=fibonac
Netty源码学习-LengthFieldBasedFrameDecoder bylijinnan java netty
先看看LengthFieldBasedFrameDecoder的官方API http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下：实
AES加密解密 chicony 加密解密
AES加解密算法，使用Base64做转码以及辅助加密： package com.wintv.common; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decod
文件编码格式转换 ctrain 编码格式
package com.test; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;
mysql 在linux客户端插入数据中文乱码 daizj mysql 中文乱码
1、查看系统客户端，数据库，连接层的编码查看方法： http://daizj.iteye.com/blog/2174993 进入mysql，通过如下命令查看数据库编码方式： mysql> show variables like 'character_set_%'; +--------------------------+------
好代码是廉价的代码 dcj3sjt126com 程序员读书
长久以来我一直主张：好代码是廉价的代码。当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。当他们走近看我的表情、知道我是认真的时，才收敛一点。当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。” 我只
Android网络请求库——android-async-http dcj3sjt126com android
在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
ORACLE 复习笔记之SQL语句的优化 eksliang SQL优化 Oracle sql语句优化 SQL语句的优化
转载请出自出处：http://eksliang.iteye.com/blog/2097999 SQL语句的优化总结如下 sql语句的优化可以按照如下六个步骤进行：合理使用索引避免或者简化排序消除对大表的扫描避免复杂的通配符匹配调整子查询的性能 EXISTS和IN运算符下面我就按照上面这六个步骤分别进行总结：
浅析：Android 嵌套滑动机制（NestedScrolling） gg163 android 移动开发滑动机制嵌套
谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性 NestedScrolling的特性可以体现在哪里呢？ 比如你使用了Toolbar，下面一个ScrollView，向上滚
使用hovertree菜单作为后台导航 hvt JavaScript jquery .net hovertree asp.net
hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。 0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm hovertree插件包含文件： http://keleyi.com/jq/hovertree/css
SVG 教程（二）矩形天梯梦 svg
SVG <rect> SVG Shapes SVG有一些预定义的形状元素，可被开发者使用和操作：矩形 <rect> 圆形 <circle> 椭圆 <ellipse> 线 <line> 折线 <polyline> 多边形 <polygon> 路径 <path>
一个简单的队列 luyulong java 数据结构队列
public class MyQueue { private long[] arr; private int front; private int end; // 有效数据的大小 private int elements; public MyQueue() { arr = new long[10]; elements = 0; front
基础数据结构和算法九：Binary Search Tree sunwinner Algorithm
A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
项目出现的一些问题和体会 Steven-Walker DAO Web servlet
第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。 dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。 &
高手问答：Java老A带你全面提升Java单兵作战能力！ ITeye管理员 java
本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论! 作者简介：淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。 CSDN博客地址： http://blog.csdn.net/xieyuooo 作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，

[22] 计算几何图形包围盒与包围球的算法

你可能感兴趣的:([22] 计算几何图形包围盒与包围球的算法)