FocusCandidate::FocusCandidate(Node* node, FocusDirection direction)
: visibleNode(0)
, focusableNode(0)
, enclosingScrollableBox(0)
, distance(maxDistance())
, parentDistance(maxDistance())
, alignment(None)
, parentAlignment(None)
, isOffscreen(true)
, isOffscreenAfterScrolling(true)
{
ASSERT(node);
ASSERT(node->isElementNode());
if (node->hasTagName(HTMLNames::areaTag)) {
HTMLAreaElement* area = static_cast<HTMLAreaElement*>(node);
HTMLImageElement* image = area->imageElement();
if (!image || !image->renderer())
return;
visibleNode = image;
rect = virtualRectForAreaElementAndDirection(area, direction);
} else {
if (!node->renderer())
return;
visibleNode = node;
rect = nodeRectInAbsoluteCoordinates(node, true /* ignore border */);
}
focusableNode = node;
isOffscreen = hasOffscreenRect(visibleNode);
isOffscreenAfterScrolling = hasOffscreenRect(visibleNode, direction);
}
int main(int argc, char const* argv[])
{
/** the size of our vectors */
const size_t N = 2;
/** the size of gravity */
const double G = 9.81;
double initVel[N];
double maxH[N];
double d;
//here
makeInitVel(1,M_PI/4,initVel);
d = maxDistance(initVel,G,N);
maxHeight(initVel,G,maxH,N);
printf("Max Distance: %f\n",d);
printf("Max Height:\n");
printf(" [ %f %f]\n",maxH[0],maxH[1]);
return 0;
}
void PannerNode::setMaxDistance(double distance)
{
if (maxDistance() == distance)
return;
// This synchronizes with process().
MutexLocker processLocker(m_processLock);
m_distanceEffect.setMaxDistance(distance);
markPannerAsDirty(PannerNode::DistanceConeGainDirty);
}
// Funtion that implements Dijkstra's single source shortest path
// algorithm for a graph represented using adjacency matrix
// representation
void dijkstra(int graph[V][V], int src)
{
int dist[V]; // The output array. dist[i] will hold
// the shortest distance from src to i
// sptSet[i] will true if vertex i is included / in shortest
// path tree or shortest distance from src to i is finalized
bool sptSet[V];
// Parent array to store shortest path tree
int parent[V];
// Initialize all distances as INFINITE and stpSet[] as false
for (int i = 0; i < V; i++)
{
parent[0] = -1;
dist[i] = INT_MIN;
sptSet[i] = false;
}
// Distance of source vertex from itself is always 0
dist[src] = 0;
// Find shortest path for all vertices
for (int count = 0; count < V-1; count++)
{
// Pick the minimum distance vertex from the set of
// vertices not yet processed. u is always equal to src
// in first iteration.
int u = maxDistance(dist, sptSet);
// Mark the picked vertex as processed
sptSet[u] = true;
// Update dist value of the adjacent vertices of the
// picked vertex.
for (int v = 0; v < V; v++)
// Update dist[v] only if is not in sptSet, there is
// an edge from u to v, and total weight of path from
// src to v through u is smaller than current value of
// dist[v]
if (!sptSet[v] && graph[u][v] &&
dist[u] + graph[u][v] > dist[v])
{
parent[v] = u;
dist[v] = dist[u] + graph[u][v];
}
}
// print the constructed distance array
printSolution(dist, V, parent);
}
void FocusController::deepFindFocusableNodeInDirection(Node* container, Node* focusedNode,
FocusDirection direction, KeyboardEvent* event,
FocusCandidate& closest,
const IntRect* specificRect)
{
ASSERT(container->isFrameOwnerElement() || isScrollableContainerNode(container));
// Track if focusedNode is a descendant of the current container node being processed.
bool descendantOfContainer = false;
Node* firstChild = 0;
if (container->isFrameOwnerElement()) {
HTMLFrameOwnerElement* owner = static_cast<HTMLFrameOwnerElement*>(container);
if (!owner->contentFrame())
return;
Document* innerDocument = owner->contentFrame()->document();
if (!innerDocument)
return;
descendantOfContainer = isNodeDeepDescendantOfDocument(focusedNode, innerDocument);
firstChild = innerDocument->firstChild();
// Scrollable block elements (e.g. <div>, etc)
} else if (isScrollableContainerNode(container) && !container->renderer()->isTextArea()) {
firstChild = container->firstChild();
descendantOfContainer = focusedNode->isDescendantOf(container);
}
if (descendantOfContainer) {
findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closest, FocusCandidate(), specificRect);
return;
}
// Check if the current container element itself is a good candidate
// to move focus to. If it is, then we traverse its inner nodes.
FocusCandidate candidateParent = FocusCandidate(container);
distanceDataForNode(direction, focusedNode, candidateParent);
// Bail out if distance is maximum.
if (candidateParent.distance == maxDistance())
return;
// FIXME: Consider alignment?
if (candidateParent.distance < closest.distance)
findFocusableNodeInDirection(firstChild, focusedNode, direction, event, closest, candidateParent, specificRect);
}
Object3D::Object3D(qreal *dots, int r, int * links, int totalLinksCount){
// Загружаем координаты точек объекта
objectDots = new qreal * [r];
dotsCount = r;
for (int j = zero; j < r; j++){
objectDots[j] = new qreal [three];
for (int i = zero; i < three; i++)
objectDots[j][i] = dots[j*three + i];
}
// Загружаем связи точек
dotsLinks = new int [totalLinksCount];
linksCount = totalLinksCount / 2;
for (int j = zero; j < totalLinksCount; j++){
dotsLinks[j] = links[j];
}
maxD = maxDistance();
}
void distanceDataForNode(FocusDirection direction, Node* start, FocusCandidate& candidate)
{
RenderObject* startRender = start->renderer();
if (!startRender) {
candidate.distance = maxDistance();
return;
}
RenderObject* destRender = candidate.node->renderer();
if (!destRender) {
candidate.distance = maxDistance();
return;
}
IntRect curRect = renderRectRelativeToRootDocument(startRender);
IntRect targetRect = renderRectRelativeToRootDocument(destRender);
// The bounding rectangle of two consecutive nodes can overlap. In such cases,
// deflate both.
deflateIfOverlapped(curRect, targetRect);
// If empty rects or negative width or height, bail out.
if (curRect.isEmpty() || targetRect.isEmpty()
|| targetRect.width() <= 0 || targetRect.height() <= 0) {
candidate.distance = maxDistance();
return;
}
// Negative coordinates can be used if node is scrolled up offscreen.
if (!checkNegativeCoordsForNode(start, curRect)) {
candidate.distance = maxDistance();
return;
}
if (!checkNegativeCoordsForNode(candidate.node, targetRect)) {
candidate.distance = maxDistance();
return;
}
if (!isRectInDirection(direction, curRect, targetRect)) {
candidate.distance = maxDistance();
return;
}
// The distance between two nodes is not to be considered alone when evaluating/looking
// for the best focus candidate node. Alignment of rects can be also a good point to be
// considered in order to make the algorithm to behavior in a more intuitive way.
candidate.alignment = alignmentForRects(direction, curRect, targetRect);
candidate.distance = spatialDistance(direction, curRect, targetRect);
}
void FocusController::findFocusableNodeInDirection(Node* outer, Node* focusedNode,
FocusDirection direction, KeyboardEvent* event,
FocusCandidate& closest, const FocusCandidate& candidateParent)
#endif
{
#if PLATFORM(WKC)
CRASH_IF_STACK_OVERFLOW(WKC_STACK_MARGIN_DEFAULT);
#endif
ASSERT(outer);
ASSERT(candidateParent.isNull()
|| candidateParent.node->isFrameOwnerElement()
|| isScrollableContainerNode(candidateParent.node));
// Walk all the child nodes and update closest if we find a nearer node.
Node* node = outer;
while (node) {
// Inner documents case.
if (node->isFrameOwnerElement()) {
deepFindFocusableNodeInDirection(node, focusedNode, direction, event, closest, specificRect);
// Scrollable block elements (e.g. <div>, etc) case.
} else if (isScrollableContainerNode(node) && !node->renderer()->isTextArea()) {
deepFindFocusableNodeInDirection(node, focusedNode, direction, event, closest, specificRect);
node = node->traverseNextSibling();
continue;
#if PLATFORM(WKC)
} else if (node != focusedNode && node->isFocusable() && isNodeInSpecificRect(node, specificRect)) {
#else
} else if (node != focusedNode && node->isKeyboardFocusable(event)) {
#endif
FocusCandidate candidate(node);
// There are two ways to identify we are in a recursive call from deepFindFocusableNodeInDirection
// (i.e. processing an element in an iframe, frame or a scrollable block element):
// 1) If candidateParent is not null, and it holds the distance and alignment data of the
// parent container element itself;
// 2) Parent of outer is <frame> or <iframe>;
// 3) Parent is any other scrollable block element.
if (!candidateParent.isNull()) {
candidate.parentAlignment = candidateParent.alignment;
candidate.parentDistance = candidateParent.distance;
candidate.enclosingScrollableBox = candidateParent.node;
} else if (!isInRootDocument(outer)) {
#if PLATFORM(WKC)
if (outer->parent() && outer->parent()->isDocumentNode()) {
Document* document = static_cast<Document*>(outer->parent());
candidate.enclosingScrollableBox = static_cast<Node*>(document->ownerElement());
}
#else
if (Document* document = static_cast<Document*>(outer->parent()))
candidate.enclosingScrollableBox = static_cast<Node*>(document->ownerElement());
#endif
} else if (isScrollableContainerNode(outer->parent()))
candidate.enclosingScrollableBox = outer->parent();
// Get distance and alignment from current candidate.
distanceDataForNode(direction, focusedNode, candidate);
// Bail out if distance is maximum.
if (candidate.distance == maxDistance()) {
node = node->traverseNextNode(outer->parent());
continue;
}
updateFocusCandidateIfCloser(focusedNode, candidate, closest);
}
node = node->traverseNextNode(outer->parent());
}
}
int main(){
int input[] = {7, 6, 8, 4};
int length = sizeof(input)/sizeof(input[0]);
printf("length: %d\n", length);
printf("distance: %d\n", maxDistance(input, length));
}
BoundaryOperator<BasisFunctionType, ResultType>
modifiedHelmholtz3dAdjointDoubleLayerBoundaryOperator(
const shared_ptr<const Context<BasisFunctionType, ResultType>> &context,
const shared_ptr<const Space<BasisFunctionType>> &domain,
const shared_ptr<const Space<BasisFunctionType>> &range,
const shared_ptr<const Space<BasisFunctionType>> &dualToRange,
KernelType waveNumber, const std::string &label, int symmetry,
bool useInterpolation, int interpPtsPerWavelength) {
const AssemblyOptions &assemblyOptions = context->assemblyOptions();
if (assemblyOptions.assemblyMode() == AssemblyOptions::ACA &&
assemblyOptions.acaOptions().mode == AcaOptions::LOCAL_ASSEMBLY)
return modifiedHelmholtz3dSyntheticBoundaryOperator(
&modifiedHelmholtz3dAdjointDoubleLayerBoundaryOperator<
BasisFunctionType, KernelType, ResultType>,
context, domain, range, dualToRange, waveNumber, label, symmetry,
useInterpolation, interpPtsPerWavelength, NO_SYMMETRY);
typedef typename ScalarTraits<BasisFunctionType>::RealType CoordinateType;
typedef Fiber::ModifiedHelmholtz3dAdjointDoubleLayerPotentialKernelFunctor<
KernelType> NoninterpolatedKernelFunctor;
typedef Fiber::
ModifiedHelmholtz3dAdjointDoubleLayerPotentialKernelInterpolatedFunctor<
KernelType> InterpolatedKernelFunctor;
typedef Fiber::ScalarFunctionValueFunctor<CoordinateType>
TransformationFunctor;
typedef Fiber::SimpleTestScalarKernelTrialIntegrandFunctorExt<
BasisFunctionType, KernelType, ResultType, 1> IntegrandFunctor;
if (!domain || !range || !dualToRange)
throw std::invalid_argument(
"modifiedHelmholtz3dAdjointDoubleLayerBoundaryOperator(): "
"domain, range and dualToRange must not be null");
shared_ptr<Fiber::TestKernelTrialIntegral<BasisFunctionType, KernelType,
ResultType>> integral;
if (shouldUseBlasInQuadrature(assemblyOptions, *domain, *dualToRange))
integral.reset(new Fiber::TypicalTestScalarKernelTrialIntegral<
BasisFunctionType, KernelType, ResultType>());
else
integral.reset(new Fiber::DefaultTestKernelTrialIntegral<IntegrandFunctor>(
IntegrandFunctor()));
typedef GeneralElementarySingularIntegralOperator<BasisFunctionType,
KernelType, ResultType> Op;
shared_ptr<Op> newOp;
if (useInterpolation)
newOp.reset(
new Op(domain, range, dualToRange, label, symmetry,
InterpolatedKernelFunctor(
waveNumber,
1.1 * maxDistance(*domain->grid(), *dualToRange->grid()),
interpPtsPerWavelength),
TransformationFunctor(), TransformationFunctor(), integral));
else
newOp.reset(new Op(domain, range, dualToRange, label, symmetry,
NoninterpolatedKernelFunctor(waveNumber),
TransformationFunctor(), TransformationFunctor(),
integral));
return BoundaryOperator<BasisFunctionType, ResultType>(context, newOp);
}
BoundaryOperator<BasisFunctionType, ResultType>
modifiedHelmholtz3dHypersingularBoundaryOperator(
const shared_ptr<const Context<BasisFunctionType, ResultType>> &context,
const shared_ptr<const Space<BasisFunctionType>> &domain,
const shared_ptr<const Space<BasisFunctionType>> &range,
const shared_ptr<const Space<BasisFunctionType>> &dualToRange,
KernelType waveNumber, const std::string &label, int symmetry,
bool useInterpolation, int interpPtsPerWavelength,
const BoundaryOperator<BasisFunctionType, ResultType> &externalSlp) {
const AssemblyOptions &assemblyOptions = context->assemblyOptions();
if ((assemblyOptions.assemblyMode() == AssemblyOptions::ACA &&
assemblyOptions.acaOptions().mode == AcaOptions::LOCAL_ASSEMBLY) ||
externalSlp.isInitialized())
return modifiedHelmholtz3dSyntheticHypersingularBoundaryOperator(
context, domain, range, dualToRange, waveNumber, label, symmetry,
useInterpolation, interpPtsPerWavelength, externalSlp);
typedef typename ScalarTraits<BasisFunctionType>::RealType CoordinateType;
typedef Fiber::ModifiedHelmholtz3dHypersingularKernelFunctor<KernelType>
NoninterpolatedKernelFunctor;
typedef Fiber::ModifiedHelmholtz3dHypersingularKernelInterpolatedFunctor<
KernelType> InterpolatedKernelFunctor;
typedef Fiber::ModifiedHelmholtz3dHypersingularTransformationFunctor<
CoordinateType> TransformationFunctor;
typedef Fiber::ModifiedHelmholtz3dHypersingularIntegrandFunctor2<
BasisFunctionType, KernelType, ResultType> IntegrandFunctor;
typedef Fiber::ModifiedHelmholtz3dHypersingularTransformationFunctor2<
CoordinateType> TransformationFunctorWithBlas;
typedef Fiber::
ModifiedHelmholtz3dHypersingularOffDiagonalInterpolatedKernelFunctor<
KernelType> OffDiagonalInterpolatedKernelFunctor;
typedef Fiber::ModifiedHelmholtz3dHypersingularOffDiagonalKernelFunctor<
KernelType> OffDiagonalNoninterpolatedKernelFunctor;
typedef Fiber::ScalarFunctionValueFunctor<CoordinateType>
OffDiagonalTransformationFunctor;
typedef Fiber::SimpleTestScalarKernelTrialIntegrandFunctorExt<
BasisFunctionType, KernelType, ResultType, 1> OffDiagonalIntegrandFunctor;
CoordinateType maxDistance_ =
static_cast<CoordinateType>(1.1) *
maxDistance(*domain->grid(), *dualToRange->grid());
shared_ptr<Fiber::TestKernelTrialIntegral<BasisFunctionType, KernelType,
ResultType>> integral,
offDiagonalIntegral;
if (shouldUseBlasInQuadrature(assemblyOptions, *domain, *dualToRange)) {
integral.reset(new Fiber::TypicalTestScalarKernelTrialIntegral<
BasisFunctionType, KernelType, ResultType>());
offDiagonalIntegral = integral;
} else {
integral.reset(new Fiber::DefaultTestKernelTrialIntegral<IntegrandFunctor>(
IntegrandFunctor()));
offDiagonalIntegral.reset(
new Fiber::DefaultTestKernelTrialIntegral<OffDiagonalIntegrandFunctor>(
OffDiagonalIntegrandFunctor()));
}
typedef GeneralHypersingularIntegralOperator<BasisFunctionType, KernelType,
ResultType> Op;
shared_ptr<Op> newOp;
if (shouldUseBlasInQuadrature(assemblyOptions, *domain, *dualToRange)) {
shared_ptr<Fiber::TestKernelTrialIntegral<BasisFunctionType, KernelType,
ResultType>> integral,
offDiagonalIntegral;
integral.reset(new Fiber::TypicalTestScalarKernelTrialIntegral<
BasisFunctionType, KernelType, ResultType>());
offDiagonalIntegral = integral;
if (useInterpolation)
newOp.reset(new Op(
domain, range, dualToRange, label, symmetry,
InterpolatedKernelFunctor(waveNumber, maxDistance_,
interpPtsPerWavelength),
TransformationFunctorWithBlas(), TransformationFunctorWithBlas(),
integral, OffDiagonalInterpolatedKernelFunctor(
waveNumber, maxDistance_, interpPtsPerWavelength),
OffDiagonalTransformationFunctor(),
OffDiagonalTransformationFunctor(), offDiagonalIntegral));
else
newOp.reset(new Op(
domain, range, dualToRange, label, symmetry,
NoninterpolatedKernelFunctor(waveNumber),
TransformationFunctorWithBlas(), TransformationFunctorWithBlas(),
integral, OffDiagonalNoninterpolatedKernelFunctor(waveNumber),
OffDiagonalTransformationFunctor(),
OffDiagonalTransformationFunctor(), offDiagonalIntegral));
} else { // no blas
if (useInterpolation)
newOp.reset(new Op(
domain, range, dualToRange, label, symmetry,
InterpolatedKernelFunctor(waveNumber, maxDistance_,
interpPtsPerWavelength),
TransformationFunctor(), TransformationFunctor(), IntegrandFunctor(),
OffDiagonalInterpolatedKernelFunctor(waveNumber, maxDistance_,
interpPtsPerWavelength),
OffDiagonalTransformationFunctor(),
OffDiagonalTransformationFunctor(), OffDiagonalIntegrandFunctor()));
else
newOp.reset(new Op(
domain, range, dualToRange, label, symmetry,
NoninterpolatedKernelFunctor(waveNumber), TransformationFunctor(),
TransformationFunctor(), IntegrandFunctor(),
OffDiagonalNoninterpolatedKernelFunctor(waveNumber),
OffDiagonalTransformationFunctor(),
OffDiagonalTransformationFunctor(), OffDiagonalIntegrandFunctor()));
}
return BoundaryOperator<BasisFunctionType, ResultType>(context, newOp);
}
