//Projection of V onto this vector
Vector Vector::Project(Vector v)
{
Vector p(X,Y);
p.Divide(GetMagnitude());
p.Multiply(DotProduct(v) / GetMagnitude());
return p;
}
int main() {
std::vector<cv::Mat> images = CreateTestMats();
cv::Mat uflow, cflow, flow;
cv::calcOpticalFlowFarneback(images[0], images[1], uflow, 0.5, 3, 5, 3, 5,
1.1, 0);
auto optical_flow = oflow::utils::GetOpticalFlow(uflow);
// cv::cvtColor(images[0], cflow, cv::COLOR_GRAY2BGR);
// uflow.copyTo(flow);
// cv::drawOptFlowMap(flow, cflow, 11, 1.5, cv::Scalar(0, 255, 0));
cv::namedWindow("Magnitude", 1);
imshow("Magnitude", ResizeImage(optical_flow.GetMagnitude()));
cv::namedWindow("Vx", 1);
imshow("Vx", ResizeImage(optical_flow.GetVx()));
cv::namedWindow("Vy", 1);
imshow("Vy", ResizeImage(optical_flow.GetVy()));
cv::namedWindow("Orientation", 1);
imshow("Orientation", ResizeImage(optical_flow.GetOrientation()));
std::cout << "Orientation: " << std::endl << optical_flow.GetOrientation()
<< std::endl;
cv::waitKey(0);
}
void NormalizeFeatureVector(vector<float> &listValue)
{
float vectorLength = GetMagnitude(listValue);
for (int i = 0; i < (int)listValue.size(); i++)
{
listValue[i] /= (float)vectorLength;
}
}
//+===================================+//
// Normalise the Vec2
// returns result as a Vec2
//+===================================+//
Vec2 Vec2::NormaliseVec2()
{
float fMag = GetMagnitude();
if( fMag != 0.f )
{
return Vec2( ( m_fX / fMag ), ( m_fY / fMag ) );
}
return Vec2( 0, 0 );
}
//------------------------------------------------------------------------------
// Rvector3 GetUnitVector() const
//------------------------------------------------------------------------------
Rvector3 Rvector3::GetUnitVector() const
{
Real mag = GetMagnitude();
if (GmatMathUtil::IsZero(mag))
throw ZeroVector(" from Rvector3::GetUnitVector()\n");
return Rvector3(elementD[0]/mag, elementD[1]/mag, elementD[2]/mag);
}
Vector4D Vector4D::Normalized()
{
float magnitude = GetMagnitude();
BML::Vector4D result;
result.m_x = m_x / magnitude;
result.m_y = m_y / magnitude;
result.m_z = m_z / magnitude;
result.m_w = m_w / magnitude;
return result;
}
void Vector4D::Normalize()
{
//Normalize the vector
float magnitude = GetMagnitude();
m_x /= magnitude;
m_y /= magnitude;
m_z /= magnitude;
m_w /= magnitude;
}
void Vector2::Normalize(float length)
{
float mag = GetMagnitude();
x /= mag;
y /= mag;
if (length != 1.0f)
{
x *= length;
y *= length;
}
}
void ZFXQuat::Normalize()
{
float m = GetMagnitude();
if (m != 0)
{
x /= m;
y /= m;
z /= m;
w /= m;
}
}
//------------------------------------------------------------------------------
// const Rvector3& Normalize()
//------------------------------------------------------------------------------
const Rvector3& Rvector3::Normalize()
{
Real mag = GetMagnitude();
if (GmatMathUtil::IsZero(mag))
throw ZeroVector(" from Rvector3::Normalize()\n");
elementD[0] /= mag;
elementD[1] /= mag;
elementD[2] /= mag;
return *this;
}
void CollisionSystem::SlowEntity(std::shared_ptr<Entity> slowingEntity,
std::shared_ptr<Entity> movingEntity)
{
auto slowingComponent = std::static_pointer_cast<SlowingComponent>(Engine::GetInstance().GetSingleComponentOfClass(slowingEntity, "SlowingComponent"));
auto particleComponent = std::static_pointer_cast<ParticleComponent>(Engine::GetInstance().GetSingleComponentOfClass(movingEntity, "ParticleComponent"));
float magnitude = slowingComponent->GetMagnitude();
Vector velocity = particleComponent->GetVelocity();
velocity *= magnitude;
particleComponent->SetVelocity(velocity);
}
XBOX_AxisState XBOX360_Controller::Get_AxisState()
{
XBOX_AxisState retval;
retval.Raw_LX = ((GetRawAxis(XBOX360_LEFT_X)*GetRawAxis(XBOX360_LEFT_X)) > LSxDZ ) ? GetRawAxis(XBOX360_LEFT_X) : 0.0;
retval.Raw_LY = ((GetRawAxis(XBOX360_LEFT_Y)*GetRawAxis(XBOX360_LEFT_Y)) > LSyDZ ) ? GetRawAxis(XBOX360_LEFT_Y) : 0.0;
retval.Raw_RX = ((GetRawAxis(XBOX360_RIGHT_X)*GetRawAxis(XBOX360_RIGHT_X))> RSxDZ) ? GetRawAxis(XBOX360_RIGHT_X) : 0.0;
retval.Raw_RY = ((GetRawAxis(XBOX360_RIGHT_Y)*GetRawAxis(XBOX360_RIGHT_Y))> RSyDZ) ? GetRawAxis(XBOX360_RIGHT_Y) : 0.0;
retval.RTrigger = (GetRawAxis(XBOX360_RTRIGGER) > RtrigDZ) ? GetRawAxis(XBOX360_RTRIGGER) : 0.0;
retval.LTrigger = (GetRawAxis(XBOX360_LTRIGGER) > LtrigDZ) ? GetRawAxis(XBOX360_LTRIGGER) : 0.0;
retval.Magnitude = GetMagnitude();
retval.RelativeHeading = GetDirectionDegrees();
return retval;
}
void CAudio::GetPowerSpectrum(double* ps,const double* data,unsigned long size)
{
ENTER_SECTION(this);
// Just lerp-copy the array
for(unsigned long x = 0; x < size; ++x)
{
// Get magnitude of this band
double mag = GetMagnitude(-data[x],1.35,2.0,x,size);
// We put - so we get bands jumpung up instead of down
ps[x] = -max(140.0 * mag,0.0);
}
}
void Vector2d::Normalize() {
(*this) /= GetMagnitude();
}
void Vector2::Normalize()
{
float mag = GetMagnitude();
x /= mag;
y /= mag;
}
Vector2 Vector2::GetNormalized()
{
float mag = GetMagnitude();
return Vector2(x / mag, y / mag);
}
/** @details Sets the vector's angle while preserving its magnitude. The new x is calculated based
* off the cosine function and the new y is based off the sine function. The existing magnitude
* is calculated via @ref GetMagnitude and applied back to the vector after the x and y have been
* calculated.
* @warning This method uses sqrt() which can be slow!
* @param angle The new angle (in radians) for the vector.
*/
_JATTA_EXPORT void Jatta::Vector2::SetAngle(Float32 angle)
{
Float32 magnitude = GetMagnitude();
x = Math::Cos(angle) * magnitude;
y = Math::Sin(angle) * magnitude;
}
/** @warning This method uses sqrt() which can be slow!
*/
_JATTA_EXPORT Jatta::Boolean Jatta::Vector2::IsNormalized(Float32 epsilon) const
{
return Math::InEpsilon(GetMagnitude(), 1, epsilon);
}
double Vector3D::GetAngle(Vector3D v2)
{
double angle = acos(DotProduct(v2) / (GetMagnitude() * v2.GetMagnitude()));
return isnan(angle) ? 0.0 : angle;
}
Vector2 Vector2::GetNormalized(float length)
{
float mag = GetMagnitude();
return Vector2((x / mag) * length, (y / mag) * length);
}
//Return unit vector of this
Vector Vector::UnitVector()
{
Vector p(X,Y);
p.Divide(GetMagnitude());
return p;
}
/** @warning This method uses sqrt() which can be slow!
*/
_JATTA_EXPORT void Jatta::Vector2::Normalize()
{
Float32 inverseMagnitude = 1.0f / GetMagnitude();
x *= inverseMagnitude;
y *= inverseMagnitude;
}
//------------------------------------------------------------------------------
void Rvector3::ComputeLongitudeLatitude(Real &lon, Real &lat)
{
lon = GmatMathUtil::ATan2(elementD[1], elementD[0]);
lat = GmatMathUtil::ASin(elementD[2] / GetMagnitude());
}
Vector3D Vector3D::ToUnitVector()
{
double magnitude = GetMagnitude();
return this->Scale(1 / magnitude);
}
