FX_BOOL CTextBaseLine::CanMerge(CTextBaseLine* pOther) { FX_FLOAT inter_top, inter_bottom; if (!GetIntersection(m_Bottom, m_Top, pOther->m_Bottom, pOther->m_Top, inter_bottom, inter_top)) { return FALSE; } FX_FLOAT inter_h = inter_top - inter_bottom; if (inter_h < (m_Top - m_Bottom) / 2 && inter_h < (pOther->m_Top - pOther->m_Bottom) / 2) { return FALSE; } FX_FLOAT dy = (FX_FLOAT)FXSYS_fabs(m_BaseLine - pOther->m_BaseLine); for (int i = 0; i < m_TextList.GetSize(); i ++) { CTextBox* pText = (CTextBox*)m_TextList.GetAt(i); for (int j = 0; j < pOther->m_TextList.GetSize(); j ++) { CTextBox* pOtherText = (CTextBox*)pOther->m_TextList.GetAt(j); FX_FLOAT inter_left, inter_right; if (!GetIntersection(pText->m_Left, pText->m_Right, pOtherText->m_Left, pOtherText->m_Right, inter_left, inter_right)) { continue; } FX_FLOAT inter_w = inter_right - inter_left; if (inter_w < pText->m_SpaceWidth / 2 && inter_w < pOtherText->m_SpaceWidth / 2) { continue; } if (dy >= (pText->m_Bottom - pText->m_Top) / 2 || dy >= (pOtherText->m_Bottom - pOtherText->m_Top) / 2) { return FALSE; } } } return TRUE; }
void LineClipping_Clip(const struct LineClipping_Rectangle *r, struct LineClipping_Segment *s, int *done) { const int maxIter = 4; int outcode0, outcode1, i; double x, y; /*Cohen-Sutherland line clipping algorithm*/ outcode0 = Outcode(s->x0, s->y0, r); outcode1 = Outcode(s->x1, s->y1, r); i = 0; while (! Inside(outcode0, outcode1) && ! SameSide(outcode0, outcode1) && (i < maxIter)) { if (outcode0 != 0) { GetIntersection(r, s, outcode0, &x, &y); s->x0 = x; s->y0 = y; outcode0 = Outcode(x, y, r); } else { GetIntersection(r, s, outcode1, &x, &y); s->x1 = x; s->y1 = y; outcode1 = Outcode(x, y, r); } i++; } assert(i < maxIter); *done = Inside(outcode0, outcode1); }
void TCliqueOverlap::Expand(const THashSet<TInt>& SUBG, THashSet<TInt>& CAND) { if (SUBG.Len()==0) { if (m_Q.Len() >= m_minMaxCliqueSize) { m_Q.Pack(); m_maxCliques->Add(m_Q); } return; } if (CAND.Len()==0) return; //Get u that maximaze CAND intersection with neighbours of vertex u int u = MaxNbrsInCANDNodeId(SUBG, CAND); //Get neighbours of node u THashSet<TInt> nbrsU; GetNbrs(u, nbrsU); //Get relative complement of nbrsU in CAND THashSet<TInt> EXT; GetRelativeComplement(CAND, nbrsU, EXT); while(EXT.Len() != 0) { int q = GetNodeIdWithMaxDeg(EXT); // m_Q.Add(q); // THashSet<TInt> nbrsQ; GetNbrs(q, nbrsQ); // THashSet<TInt> SUBGq; GetIntersection(SUBG, nbrsQ, SUBGq); // THashSet<TInt> CANDq; GetIntersection(CAND, nbrsQ, CANDq); // Expand(SUBGq, CANDq); // CAND.DelKey(q); m_Q.DelLast(); // EXT.Clr(); GetRelativeComplement(CAND, nbrsU, EXT); } }
inline FX_BOOL _IsIntersect(const CFX_FloatRect& rectA, const CFX_FloatRect& rectB) { FX_FLOAT interlow = .0f, interhigh = .0f; if(GetIntersection(rectA.bottom, rectA.top, rectB.bottom, rectB.top, interlow, interhigh)) { if(GetIntersection(rectA.left, rectA.right, rectB.left, rectB.right, interlow, interhigh)) { return TRUE; } else { return FALSE; } } return FALSE; }
bool SoyPhysics::GetIntersection(const TCollisionShape& ShapeA,const TCollisionShape& ShapeB,TIntersection& Intersection) { // what do we have to work with... auto& PolygonA = ShapeA.GetPolygon(); auto& CapsuleA = ShapeA.GetCapsule(); auto& CircleA = ShapeA.GetCircle(); if ( PolygonA.IsValid() ) return GetIntersection( PolygonA, ShapeB, Intersection ); if ( CapsuleA.IsValid() ) return GetIntersection( CapsuleA, ShapeB, Intersection ); if ( CircleA.IsValid() ) return GetIntersection( CircleA, ShapeB, Intersection ); return false; }
//заносит результаты пересечений (отрезки) треугольников из g с треугольником tr (tr_bb - is a triangle's bounding box) void GetCrTriangles(Geometry& g,Triangle& tr,Lines& res,std::vector<LineConf>* lines_conf,Line tr_bb,float*perimeter) { if(!g.boxes.size()) { for(int i=0;i<g.tr.size();i++) if(CrossBoxes(g.tr_bb[i].v[0],g.tr_bb[i].v[1],tr_bb.v[0],tr_bb.v[1])) GetIntersection(g.tr[i],tr,res,lines_conf,perimeter); }else for(int b=0;b<g.boxes.size();b++) if(CrossBoxes(g.boxes[b].v[0],g.boxes[b].v[1],tr_bb.v[0],tr_bb.v[1])) for(int i=0;i<g.boxes[b].boxes.size();i++) { int box_id = g.boxes[b].boxes[i]; if(CrossBoxes(g.tr_bb[box_id].v[0],g.tr_bb[box_id].v[1],tr_bb.v[0],tr_bb.v[1])) GetIntersection(g.tr[box_id],tr,res,lines_conf,perimeter); } }
// // returns true if line (L1, L2) intersects with axis-aligned box (B1, B2) // The point of intersection is returned in HitP // bool CheckLineBox( CVec3 L1, CVec3 L2, CVec3 B1, CVec3 B2, CVec3 &HitP ) { // Check for a quick exit if the line is completely to one side of the box if (L2.x < B1.x && L1.x < B1.x) return false; if (L2.x > B2.x && L1.x > B2.x) return false; if (L2.y < B1.y && L1.y < B1.y) return false; if (L2.y > B2.y && L1.y > B2.y) return false; if (L2.z < B1.z && L1.z < B1.z) return false; if (L2.z > B2.z && L1.z > B2.z) return false; // Check if the line originates in the box if (L1.x > B1.x && L1.x < B2.x && L1.y > B1.y && L1.y < B2.y && L1.z > B1.z && L1.z < B2.z ) { HitP = L1; return true; } // Check for a line intersection with each side of the box if ( GetIntersection( L1.x-B1.x, L2.x-B1.x, L1, L2, HitP) && InBox( HitP, B1, B2, 1 ) ) return true; if ( GetIntersection( L1.y-B1.y, L2.y-B1.y, L1, L2, HitP) && InBox( HitP, B1, B2, 2 ) ) return true; if ( GetIntersection( L1.z-B1.z, L2.z-B1.z, L1, L2, HitP) && InBox( HitP, B1, B2, 3 ) ) return true; if ( GetIntersection( L1.x-B2.x, L2.x-B2.x, L1, L2, HitP) && InBox( HitP, B1, B2, 1 ) ) return true; if ( GetIntersection( L1.y-B2.y, L2.y-B2.y, L1, L2, HitP) && InBox( HitP, B1, B2, 2 ) ) return true; if ( GetIntersection( L1.z-B2.z, L2.z-B2.z, L1, L2, HitP) && InBox( HitP, B1, B2, 3 ) ) return true; return false; }
Intersection Cube::SampleLight( float a, float b, float c ){ glm::vec3 ray_o( 0.f ); glm::vec3 ray_d( 0.f ); a -= .5f; b -= .5f; int hit_face( c * 6.f ); switch ( hit_face ) { case 0: //--- x+ --- ray_o = glm::vec3( 1.f, a, b ); ray_d = glm::vec3( -1.f, 0.f, 0.f ); break; case 1: //--- x- --- ray_o = glm::vec3( -1.f, a, b ); ray_d = glm::vec3( 1.f, 0.f, 0.f ); break; case 2: //--- y+ --- ray_o = glm::vec3( a, 1.f, b ); ray_d = glm::vec3( 0.f, -1.f, 0.f ); break; case 3: //--- y- --- ray_o = glm::vec3( a, -1.f, b ); ray_d = glm::vec3( 0.f, 1.f, 0.f ); break; case 4: //--- z+ --- ray_o = glm::vec3( a, b, 1.f ); ray_d = glm::vec3( 0.f, 0.f, -1.f ); break; case 5: //--- z- --- ray_o = glm::vec3( a, b, -1.f ); ray_d = glm::vec3( 0.f, 0.f, 1.f ); break; } Ray ray( ray_o, ray_d ); return GetIntersection( ray.GetTransformedCopy( transform.T() ) ); }
Intersection Sphere::SampleLight( float a, float b, float c ){ float phi( PI * a ); float u( cosf( phi ) ); float theta( TWO_PI * b ); float x( sqrt( 1 - u * u ) * cosf( theta ) ); float y( sqrt( 1 - u * u ) * sinf( theta ) ); float z( u ); glm::vec3 ray_o( x * .6f, y * .6f, z * .6f ); glm::vec3 ray_d( -x, -y, -z ); Ray ray( ray_o, ray_d ); return GetIntersection( ray.GetTransformedCopy( transform.T() ) ); }
void Jaccard::CalculateJaccard() { unsigned long U = GetUnion(); delete _bedA; delete _bedB; unsigned long I = GetIntersection(); // header cout << "intersection\t" << "union\t" << "jaccard" << endl; // result cout << I << "\t" << U - I << "\t" << (float) I / ((float) U - (float) I) << endl; }
float TofGeometry::PathLengthInAPaddle(int il, int ib, AMSPoint point, AMSDir dir) { if ( (il<0)||(il>3)||(ib<0)||(ib>9) ) return false; // check intersection with every surface AMSPoint points[6]; int npoints = 0; for (int isurface=0; isurface<6; isurface++) { AMSPoint x[4] = { TofGeometry::GetPaddleSurfaceCorner(il,ib,isurface,0), TofGeometry::GetPaddleSurfaceCorner(il,ib,isurface,1), TofGeometry::GetPaddleSurfaceCorner(il,ib,isurface,2), TofGeometry::GetPaddleSurfaceCorner(il,ib,isurface,3) }; AMSPoint intersection = GetIntersection(x,point,dir); if (!IsInsideRectangle(x,intersection)) continue; points[npoints].setp(intersection.x(),intersection.y(),intersection.z()); npoints++; } // in the case of 2 intersection the particle is entering and exiting if (npoints!=2) return 0.; return (points[1] - points[0]).norm(); }
int main (int argc, char **argv) { Collection *List1, *List2, *NewList; List1 = (Collection *) malloc (sizeof (Collection)); List1->next = NULL; List2 = (Collection *) malloc (sizeof (Collection)); List2->next = NULL; srandom (time (NULL)); printf ("Original lists:\n"); CreateList (List1, 10); DispList (List1); CreateList (List2, 6); DispList (List2); printf ("Sorted lists:\n"); SortList (&List1); DispList (List1); SortList (&List2); DispList (List2); NewList = MergeList (List1, List2); printf ("Merged list:\n"); DispList (NewList); DestroyList (&NewList); NewList = GetIntersection (List1, List2); printf ("Intersection:\n"); DispList (NewList); DestroyList (&NewList); NewList = GetDiffset (List1, List2); printf ("Different set:\n"); DispList (NewList); DestroyList (&NewList); DestroyList (&List1); DestroyList (&List2); return 0; }
BOOL CcdrawDoc::AddSegment(CComplex p0, CComplex p1, CSegment &segm, double tol) { int i,j,k,n0,n1; double xi,yi,t; CComplex p[2]; CArray< CComplex, CComplex&> newnodes; newnodes.RemoveAll(); n0=ClosestNode(p0.re,p0.im); n1=ClosestNode(p1.re,p1.im); // don't add if line is degenerate if (n0==n1) return FALSE; // don't add if the line is already in the list; for(i=0;i<linelist.GetSize();i++){ if ((linelist[i].n0==n0) && (linelist[i].n1==n1)) return FALSE; if ((linelist[i].n0==n1) && (linelist[i].n1==n0)) return FALSE; } segm.IsSelected=FALSE; segm.n0=n0; segm.n1=n1; // check to see if there are intersections with segments for(i=0;i<linelist.GetSize();i++) if(GetIntersection(n0,n1,i,&xi,&yi)==TRUE) newnodes.Add(CComplex(xi,yi)); // check to see if there are intersections with arcs for(i=0;i<arclist.GetSize();i++){ j=GetLineArcIntersection(segm,arclist[i],p); if (j>0) for(k=0;k<j;k++) newnodes.Add(p[k]); } // add nodes at intersections if(tol==0) { if (nodelist.GetSize()<2) t=1.e-08; else{ CComplex p0,p1; p0=nodelist[0].CC(); p1=p0; for(i=1;i<nodelist.GetSize();i++) { if(nodelist[i].x<p0.re) p0.re=nodelist[i].x; if(nodelist[i].x>p1.re) p1.re=nodelist[i].x; if(nodelist[i].y<p0.im) p0.im=nodelist[i].y; if(nodelist[i].y>p1.im) p1.im=nodelist[i].y; } t=abs(p1-p0)*CLOSE_ENOUGH; } } else t=tol; for(i=0;i<newnodes.GetSize();i++) AddNode(newnodes[i].re,newnodes[i].im,t); // Add proposed line segment linelist.Add(segm); // check to see if proposed line passes through other points; // if so, delete line and create lines that link intermediate points; // does this by recursive use of AddSegment; double d,dmin; UnselectAll(); if (tol==0) dmin=abs(nodelist[n1].CC()-nodelist[n0].CC())*1.e-05; else dmin=tol; k=(int) linelist.GetSize()-1; for(i=0;i<nodelist.GetSize();i++) { if( (i!=n0) && (i!=n1) ) { d=ShortestDistance(nodelist[i].x,nodelist[i].y,k); // catch a special case... if (abs(nodelist[i].CC()-nodelist[n0].CC())<dmin) d=2.*dmin; if (abs(nodelist[i].CC()-nodelist[n1].CC())<dmin) d=2.*dmin; if (d<dmin){ linelist[k].ToggleSelect(); DeleteSelectedSegments(); AddSegment(n0,i,&segm,dmin); AddSegment(i,n1,&segm,dmin); i=(int) nodelist.GetSize(); } } } return TRUE; }
static VOID MainThreadProc (PVOID threadArg) { EncryptedIoQueue *queue = (EncryptedIoQueue *) threadArg; PLIST_ENTRY listEntry; EncryptedIoQueueItem *item; LARGE_INTEGER fragmentOffset; ULONG dataRemaining; PUCHAR activeFragmentBuffer = queue->FragmentBufferA; PUCHAR dataBuffer; EncryptedIoRequest *request; uint64 intersectStart; uint32 intersectLength; ULONGLONG addResult; HRESULT hResult; if (IsEncryptionThreadPoolRunning()) KeSetPriorityThread (KeGetCurrentThread(), LOW_REALTIME_PRIORITY); while (!queue->ThreadExitRequested) { if (!NT_SUCCESS (KeWaitForSingleObject (&queue->MainThreadQueueNotEmptyEvent, Executive, KernelMode, FALSE, NULL))) continue; while ((listEntry = ExInterlockedRemoveHeadList (&queue->MainThreadQueue, &queue->MainThreadQueueLock))) { PIRP irp = CONTAINING_RECORD (listEntry, IRP, Tail.Overlay.ListEntry); PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (irp); if (queue->Suspended) KeWaitForSingleObject (&queue->QueueResumedEvent, Executive, KernelMode, FALSE, NULL); item = GetPoolBuffer (queue, sizeof (EncryptedIoQueueItem)); if (!item) { TCCompleteDiskIrp (irp, STATUS_INSUFFICIENT_RESOURCES, 0); DecrementOutstandingIoCount (queue); IoReleaseRemoveLock (&queue->RemoveLock, irp); continue; } item->Queue = queue; item->OriginalIrp = irp; item->Status = STATUS_SUCCESS; IoSetCancelRoutine (irp, NULL); if (irp->Cancel) { CompleteOriginalIrp (item, STATUS_CANCELLED, 0); continue; } switch (irpSp->MajorFunction) { case IRP_MJ_READ: item->Write = FALSE; item->OriginalOffset = irpSp->Parameters.Read.ByteOffset; item->OriginalLength = irpSp->Parameters.Read.Length; break; case IRP_MJ_WRITE: item->Write = TRUE; item->OriginalOffset = irpSp->Parameters.Write.ByteOffset; item->OriginalLength = irpSp->Parameters.Write.Length; break; default: CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } #ifdef TC_TRACE_IO_QUEUE item->OriginalIrpOffset = item->OriginalOffset; #endif // Handle misaligned read operations to work around a bug in Windows System Assessment Tool which does not follow FILE_FLAG_NO_BUFFERING requirements when benchmarking disk devices if (queue->IsFilterDevice && !item->Write && item->OriginalLength > 0 && (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) == 0 && (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0) { byte *buffer; ULONG alignedLength; LARGE_INTEGER alignedOffset; hResult = ULongAdd(item->OriginalLength, ENCRYPTION_DATA_UNIT_SIZE, &alignedLength); if (hResult != S_OK) { CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } alignedOffset.QuadPart = item->OriginalOffset.QuadPart & ~((LONGLONG) ENCRYPTION_DATA_UNIT_SIZE - 1); buffer = TCalloc (alignedLength); if (!buffer) { CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0); continue; } item->Status = TCReadDevice (queue->LowerDeviceObject, buffer, alignedOffset, alignedLength); if (NT_SUCCESS (item->Status)) { UINT64_STRUCT dataUnit; dataBuffer = (PUCHAR) MmGetSystemAddressForMdlSafe (irp->MdlAddress, HighPagePriority); if (!dataBuffer) { TCfree (buffer); CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0); continue; } if (queue->EncryptedAreaStart != -1 && queue->EncryptedAreaEnd != -1) { GetIntersection (alignedOffset.QuadPart, alignedLength, queue->EncryptedAreaStart, queue->EncryptedAreaEnd, &intersectStart, &intersectLength); if (intersectLength > 0) { dataUnit.Value = intersectStart / ENCRYPTION_DATA_UNIT_SIZE; DecryptDataUnits (buffer + (intersectStart - alignedOffset.QuadPart), &dataUnit, intersectLength / ENCRYPTION_DATA_UNIT_SIZE, queue->CryptoInfo); } } memcpy (dataBuffer, buffer + (item->OriginalOffset.LowPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)), item->OriginalLength); } TCfree (buffer); CompleteOriginalIrp (item, item->Status, NT_SUCCESS (item->Status) ? item->OriginalLength : 0); continue; } // Validate offset and length if (item->OriginalLength == 0 || (item->OriginalLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0 || (item->OriginalOffset.QuadPart & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0 || ( !queue->IsFilterDevice && ( (S_OK != ULongLongAdd(item->OriginalOffset.QuadPart, item->OriginalLength, &addResult)) || (addResult > (ULONGLONG) queue->VirtualDeviceLength) ) ) ) { CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } #ifdef TC_TRACE_IO_QUEUE Dump ("Q %I64d [%I64d] %c len=%d\n", item->OriginalOffset.QuadPart, GetElapsedTime (&queue->LastPerformanceCounter), item->Write ? 'W' : 'R', item->OriginalLength); #endif if (!queue->IsFilterDevice) { // Adjust the offset for host file or device if (queue->CryptoInfo->hiddenVolume) hResult = ULongLongAdd(item->OriginalOffset.QuadPart, queue->CryptoInfo->hiddenVolumeOffset, &addResult); else hResult = ULongLongAdd(item->OriginalOffset.QuadPart, queue->CryptoInfo->volDataAreaOffset, &addResult); if (hResult != S_OK) { CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } else item->OriginalOffset.QuadPart = addResult; // Hidden volume protection if (item->Write && queue->CryptoInfo->bProtectHiddenVolume) { // If there has already been a write operation denied in order to protect the // hidden volume (since the volume mount time) if (queue->CryptoInfo->bHiddenVolProtectionAction) { // Do not allow writing to this volume anymore. This is to fake a complete volume // or system failure (otherwise certain kinds of inconsistency within the file // system could indicate that this volume has used hidden volume protection). CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } // Verify that no byte is going to be written to the hidden volume area if (RegionsOverlap ((unsigned __int64) item->OriginalOffset.QuadPart, (unsigned __int64) item->OriginalOffset.QuadPart + item->OriginalLength - 1, queue->CryptoInfo->hiddenVolumeOffset, (unsigned __int64) queue->CryptoInfo->hiddenVolumeOffset + queue->CryptoInfo->hiddenVolumeProtectedSize - 1)) { Dump ("Hidden volume protection triggered: write %I64d-%I64d (protected %I64d-%I64d)\n", item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, queue->CryptoInfo->hiddenVolumeOffset, queue->CryptoInfo->hiddenVolumeOffset + queue->CryptoInfo->hiddenVolumeProtectedSize - 1); queue->CryptoInfo->bHiddenVolProtectionAction = TRUE; // Deny this write operation to prevent the hidden volume from being overwritten CompleteOriginalIrp (item, STATUS_INVALID_PARAMETER, 0); continue; } } } else if (item->Write && RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET, TC_BOOT_VOLUME_HEADER_SECTOR_OFFSET + TC_BOOT_ENCRYPTION_VOLUME_HEADER_SIZE - 1)) { // Prevent inappropriately designed software from damaging important data that may be out of sync with the backup on the Rescue Disk (such as the end of the encrypted area). Dump ("Preventing write to the system encryption key data area\n"); CompleteOriginalIrp (item, STATUS_MEDIA_WRITE_PROTECTED, 0); continue; } else if (item->Write && IsHiddenSystemRunning() && (RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, TC_SECTOR_SIZE_BIOS, TC_BOOT_LOADER_AREA_SECTOR_COUNT * TC_SECTOR_SIZE_BIOS - 1) || RegionsOverlap (item->OriginalOffset.QuadPart, item->OriginalOffset.QuadPart + item->OriginalLength - 1, GetBootDriveLength(), _I64_MAX))) { Dump ("Preventing write to boot loader or host protected area\n"); CompleteOriginalIrp (item, STATUS_MEDIA_WRITE_PROTECTED, 0); continue; } dataBuffer = (PUCHAR) MmGetSystemAddressForMdlSafe (irp->MdlAddress, HighPagePriority); if (dataBuffer == NULL) { CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0); continue; } // Divide data block to fragments to enable efficient overlapping of encryption and IO operations dataRemaining = item->OriginalLength; fragmentOffset = item->OriginalOffset; while (dataRemaining > 0) { BOOL isLastFragment = dataRemaining <= TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE; ULONG dataFragmentLength = isLastFragment ? dataRemaining : TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE; activeFragmentBuffer = (activeFragmentBuffer == queue->FragmentBufferA ? queue->FragmentBufferB : queue->FragmentBufferA); InterlockedIncrement (&queue->IoThreadPendingRequestCount); // Create IO request request = GetPoolBuffer (queue, sizeof (EncryptedIoRequest)); if (!request) { CompleteOriginalIrp (item, STATUS_INSUFFICIENT_RESOURCES, 0); break; } request->Item = item; request->CompleteOriginalIrp = isLastFragment; request->Offset = fragmentOffset; request->Data = activeFragmentBuffer; request->OrigDataBufferFragment = dataBuffer; request->Length = dataFragmentLength; if (queue->IsFilterDevice) { if (queue->EncryptedAreaStart == -1 || queue->EncryptedAreaEnd == -1) { request->EncryptedLength = 0; } else { // Get intersection of data fragment with encrypted area GetIntersection (fragmentOffset.QuadPart, dataFragmentLength, queue->EncryptedAreaStart, queue->EncryptedAreaEnd, &intersectStart, &intersectLength); request->EncryptedOffset = intersectStart - fragmentOffset.QuadPart; request->EncryptedLength = intersectLength; } } else { request->EncryptedOffset = 0; request->EncryptedLength = dataFragmentLength; } AcquireFragmentBuffer (queue, activeFragmentBuffer); if (item->Write) { // Encrypt data memcpy (activeFragmentBuffer, dataBuffer, dataFragmentLength); if (request->EncryptedLength > 0) { UINT64_STRUCT dataUnit; ASSERT (request->EncryptedOffset + request->EncryptedLength <= request->Offset.QuadPart + request->Length); dataUnit.Value = (request->Offset.QuadPart + request->EncryptedOffset) / ENCRYPTION_DATA_UNIT_SIZE; if (queue->CryptoInfo->bPartitionInInactiveSysEncScope) dataUnit.Value += queue->CryptoInfo->FirstDataUnitNo.Value; else if (queue->RemapEncryptedArea) dataUnit.Value += queue->RemappedAreaDataUnitOffset; EncryptDataUnits (activeFragmentBuffer + request->EncryptedOffset, &dataUnit, request->EncryptedLength / ENCRYPTION_DATA_UNIT_SIZE, queue->CryptoInfo); } } // Queue IO request ExInterlockedInsertTailList (&queue->IoThreadQueue, &request->ListEntry, &queue->IoThreadQueueLock); KeSetEvent (&queue->IoThreadQueueNotEmptyEvent, IO_DISK_INCREMENT, FALSE); if (isLastFragment) break; dataRemaining -= TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE; dataBuffer += TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE; fragmentOffset.QuadPart += TC_ENC_IO_QUEUE_MAX_FRAGMENT_SIZE; } } } PsTerminateSystemThread (STATUS_SUCCESS); }
static NTSTATUS DumpFilterWrite (PFILTER_EXTENSION filterExtension, PLARGE_INTEGER diskWriteOffset, PMDL writeMdl) { ULONG dataLength = MmGetMdlByteCount (writeMdl); uint64 offset = DumpPartitionOffset.QuadPart + diskWriteOffset->QuadPart; uint64 intersectStart; uint32 intersectLength; PVOID writeBuffer; CSHORT origMdlFlags; if (BootDriveFilterExtension->MagicNumber != TC_BOOT_DRIVE_FILTER_EXTENSION_MAGIC_NUMBER) TC_BUG_CHECK (STATUS_CRC_ERROR); if (BootDriveFilterExtension->Queue.EncryptedAreaEndUpdatePending) // Hibernation should always abort the setup thread TC_BUG_CHECK (STATUS_INVALID_PARAMETER); if (BootDriveFilterExtension->Queue.EncryptedAreaStart == -1 || BootDriveFilterExtension->Queue.EncryptedAreaEnd == -1) return STATUS_SUCCESS; if (dataLength > WriteFilterBufferSize) TC_BUG_CHECK (STATUS_BUFFER_OVERFLOW); // Bug check is required as returning an error does not prevent data from being written to disk if ((dataLength & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0) TC_BUG_CHECK (STATUS_INVALID_PARAMETER); if ((offset & (ENCRYPTION_DATA_UNIT_SIZE - 1)) != 0) TC_BUG_CHECK (STATUS_INVALID_PARAMETER); writeBuffer = MmGetSystemAddressForMdlSafe (writeMdl, HighPagePriority); if (!writeBuffer) TC_BUG_CHECK (STATUS_INSUFFICIENT_RESOURCES); memcpy (WriteFilterBuffer, writeBuffer, dataLength); GetIntersection (offset, dataLength, BootDriveFilterExtension->Queue.EncryptedAreaStart, BootDriveFilterExtension->Queue.EncryptedAreaEnd, &intersectStart, &intersectLength); if (intersectLength > 0) { UINT64_STRUCT dataUnit; dataUnit.Value = intersectStart / ENCRYPTION_DATA_UNIT_SIZE; if (BootDriveFilterExtension->Queue.RemapEncryptedArea) { diskWriteOffset->QuadPart += BootDriveFilterExtension->Queue.RemappedAreaOffset; dataUnit.Value += BootDriveFilterExtension->Queue.RemappedAreaDataUnitOffset; } EncryptDataUnitsCurrentThread (WriteFilterBuffer + (intersectStart - offset), &dataUnit, intersectLength / ENCRYPTION_DATA_UNIT_SIZE, BootDriveFilterExtension->Queue.CryptoInfo); } origMdlFlags = writeMdl->MdlFlags; MmInitializeMdl (writeMdl, WriteFilterBuffer, dataLength); MmBuildMdlForNonPagedPool (writeMdl); // Instead of using MmGetSystemAddressForMdlSafe(), some buggy custom storage drivers may directly test MDL_MAPPED_TO_SYSTEM_VA flag, // disregarding the fact that other MDL flags may be set by the system or a dump filter (e.g. MDL_SOURCE_IS_NONPAGED_POOL flag only). // Therefore, to work around this issue, the original flags will be restored even if they do not match the new MDL. // MS BitLocker also uses this hack/workaround (it should be safe to use until the MDL structure is changed). writeMdl->MdlFlags = origMdlFlags; return STATUS_SUCCESS; }
void CollectNode(void *node, TArray<FCoverageVertex> &shape) { static TArray<FCoverageLine> lists[2]; const double COVERAGE_EPSILON = 6.; // same epsilon as the node builder if (!((size_t)node & 1)) // Keep going until found a subsector { node_t *bsp = (node_t *)node; int centerside = R_PointOnSide(center.x, center.y, bsp); lists[0].Clear(); lists[1].Clear(); for(unsigned i=0;i<shape.Size(); i++) { FCoverageVertex *v1 = &shape[i]; FCoverageVertex *v2 = &shape[(i+1) % shape.Size()]; FCoverageLine vl = {{*v1, *v2}}; double dist_v1 = PartitionDistance(v1, bsp); double dist_v2 = PartitionDistance(v2, bsp); if(dist_v1 <= COVERAGE_EPSILON) { if (dist_v2 <= COVERAGE_EPSILON) { lists[centerside].Push(vl); } else { int side = PointOnSide(v2, bsp); lists[side].Push(vl); } } else if (dist_v2 <= COVERAGE_EPSILON) { int side = PointOnSide(v1, bsp); lists[side].Push(vl); } else { int side1 = PointOnSide(v1, bsp); int side2 = PointOnSide(v2, bsp); if(side1 != side2) { // if the partition line crosses this seg, we must split it. FCoverageVertex vert; if (GetIntersection(v1, v2, bsp, &vert)) { lists[0].Push(vl); lists[1].Push(vl); lists[side1].Last().v[1] = vert; lists[side2].Last().v[0] = vert; } else { // should never happen lists[side1].Push(vl); } } else { // both points on the same side. lists[side1].Push(vl); } } } if (lists[1].Size() == 0) { CollectNode(bsp->children[0], shape); } else if (lists[0].Size() == 0) { CollectNode(bsp->children[1], shape); } else { // copy the static arrays into local ones TArray<FCoverageVertex> locallists[2]; for(int l=0;l<2;l++) { for (unsigned i=0;i<lists[l].Size(); i++) { locallists[l].Push(lists[l][i].v[0]); unsigned i1= (i+1)%lists[l].Size(); if (lists[l][i1].v[0] != lists[l][i].v[1]) { locallists[l].Push(lists[l][i].v[1]); } } } CollectNode(bsp->children[0], locallists[0]); CollectNode(bsp->children[1], locallists[1]); } } else { // we reached a subsector so we can link the node with this subsector subsector_t *sub = (subsector_t *)((BYTE *)node - 1); collect.Push(int(sub-subsectors)); } }
bool IntrTriangle2Triangle2<Real>::Find (Real tmax, const Vector2<Real>& velocity0, const Vector2<Real>& velocity1) { // Process as if V0-triangle is stationary and V1-triangle is moving. Vector2<Real> W = velocity1 - velocity0; int side = 0; // 0 = NONE, -1 = LEFT, +1 = RIGHT Real tfirst = (Real)0; Real tlast = Math<Real>::MAX_REAL; Configuration cfg0, cfg1, tcfg0, tcfg1; int i0, i1, i2; Vector2<Real> D; Real speed; // Process edges of V0-triangle. for (i0 = 1, i1 = 2, i2 = 0; i2 < 3; i0 = i1, i1 = i2++) { // Test axis V0[i1] + t*perp(V0[i2]-V0[i1]), perp(x,y) = (y,-x). D.X() = mTriangle0->V[i2].Y() - mTriangle0->V[i1].Y(); D.Y() = mTriangle0->V[i1].X() - mTriangle0->V[i2].X(); speed = D.Dot(W); ComputeTwo(cfg0, mTriangle0->V, D, i0, i1, i2); ComputeThree(cfg1, mTriangle1->V, D, mTriangle0->V[i1]); if (NoIntersect(cfg0, cfg1, tmax, speed, side, tcfg0, tcfg1, tfirst, tlast)) { return false; } } // Process edges of V1-triangle. for (i0 = 1, i1 = 2, i2 = 0; i2 < 3; i0 = i1, i1 = i2++) { // Test axis V1[i1] + t*perp(V1[i2]-V1[i1]), perp(x,y) = (y,-x). D.X() = mTriangle1->V[i2].Y() - mTriangle1->V[i1].Y(); D.Y() = mTriangle1->V[i1].X() - mTriangle1->V[i2].X(); speed = D.Dot(W); ComputeTwo(cfg1, mTriangle1->V, D, i0, i1, i2); ComputeThree(cfg0, mTriangle0->V, D, mTriangle1->V[i1]); if (NoIntersect(cfg0, cfg1, tmax, speed, side, tcfg0, tcfg1, tfirst, tlast)) { return false; } } // Move triangles to first contact. Vector2<Real> moveV0[3], moveV1[3]; for (int i = 0; i < 3; ++i) { moveV0[i] = mTriangle0->V[i] + tfirst*velocity0; moveV1[i] = mTriangle1->V[i] + tfirst*velocity1; }; GetIntersection(tcfg0, tcfg1, side, moveV0, moveV1, mQuantity, mPoint); mContactTime = tfirst; return mQuantity > 0; }
//============================================================================ // NGeometryUtilities::ClipPolygonToEdge : Clip a polygon to an edge. //---------------------------------------------------------------------------- template<class T> void NGeometryUtilities::ClipPolygonToEdge( const NPointT<T> &edgeStart, const NPointT<T> &edgeEnd, const std::vector< NPointT<T> > &theInput, std::vector< NPointT<T> > &theOutput) { NIndex n, numPoints; NPointT<T> s, p, i; // Get the state we need // // Since most polygons produce a similar size of output, we reserve space up front. theOutput.clear(); numPoints = theInput.size(); if (numPoints == 0) return; theOutput.reserve(numPoints); // Perform the clip // // Each segment is compared to the clipping edge, which gives four cases: // // 1) Both endpoints (s and p) are inside the clipping edge, so p is added. // 2) Both endpoints (s and p) are outside the clipping edge, so nothing is added. // 3) Vertex s is inside and p is outside, so the intersection (i) is added. // 4) Vertex p is inside and s is outside, so the intersection (i) and p are added. // s = theInput[numPoints - 1]; for (n = 0; n < numPoints; n++) { p = theInput[n]; // Cases 1 or 4 if (IsInside(edgeStart, edgeEnd, p)) { // Case 1 if (IsInside(edgeStart, edgeEnd, s)) theOutput.push_back(p); // Case 4 else { i = GetIntersection(edgeStart, edgeEnd, s, p); theOutput.push_back(i); theOutput.push_back(p); } } // Cases 2 or 3 else { // Case 3 if (IsInside(edgeStart, edgeEnd, s)) { i = GetIntersection(edgeStart, edgeEnd, s, p); theOutput.push_back(i); } // Case 2 else { } } s = p; } }
TEST(intersection, triangle_tetrahedron) { TIntersectionType it; double area; // create tetrahedron TPoint point0(0.00, 0.00, 0.00); TPoint point1(3.00, 0.00, 0.00); TPoint point2(0.00, 3.00, 0.00); TPoint point3(0.00, 0.00, 3.00); TTetrahedron tetrahedron(point0, point1, point2, point3); // triangle is in tetrahedron TPoint pointA(0.50, 0.50, 0.50); TPoint pointB(0.50, 1.50, 0.50); TPoint pointC(1.50, 0.50, 0.50); TTriangle triangle(pointA, pointB, pointC); xprintf(Msg, "Test - triangle is in tetrahedron\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 0.5); // triangle is greater than tetrahedron, intersection is triangle pointA.SetCoord(-3.0, 2.0, 2.0); pointB.SetCoord(2.0, -3.0, 2.0); pointC.SetCoord(2.0, 2.0, 2.0); triangle.SetPoints(pointA, pointB, pointC); xprintf(Msg, "Test - triangle is greater than tetrahedron, intersection is triangle\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 0.5); // intersection is tetragon pointA.SetCoord(-0.50, 0.50, 1.00); pointB.SetCoord(2.00, 0.50, 1.00); pointC.SetCoord(2.00, 3.00, 1.00); triangle.SetPoints(pointA, pointB, pointC); xprintf(Msg, "Test - intersection is tetragon\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 0.875); // intersection is pentagon pointA.SetCoord(-1.0, 2.00, 1.00); pointB.SetCoord(1.50, 2.00, 1.00); pointC.SetCoord(1.50,-0.5 , 1.00); triangle.SetPoints(pointA, pointB, pointC); xprintf(Msg, "Test - intersection is pentagon\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 0.5+0.5+0.5*3.0/4.0); // intersection is hexagon (plane parallel to x-y) pointA.SetCoord(2.00, 2.00, 0.50); pointB.SetCoord(2.00, -1.00, 0.50); pointC.SetCoord(-1.00, 2.00, 0.50); triangle.SetPoints(pointA, pointB, pointC); xprintf(Msg, "Test - intersection is hexagon (plane parallel to x-y)\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 2.375); // intersection is hexagon pointA.SetCoord(0.25, 2.00, 1.00); pointB.SetCoord(2.25, 1.00, -1.00); pointC.SetCoord(0.25, -1.00, 3.00); triangle.SetPoints(pointA, pointB, pointC); xprintf(Msg, "Test - intersection is hexagon\n"); GetIntersection(triangle, tetrahedron, it, area); EXPECT_FLOAT_EQ(area, 3.477919); }