from System import Array

import Accord
import Accord.Math
import clr
clr.ImportExtensions(Accord.Math)

Accord.Math.Matrix.Indices(0, 10)

from Accord.Math import Matrix
v = Matrix.Identity(3)
v

I = Array.CreateInstance(float, 2, 2)
I[0,0] = 1
I

u = Array[float]([1, 6])
v = Array[float]([-2, 10])

u.InnerProduct(v)

outer = u.OuterProduct(v)
outer

I.Multiply(u)

I.Multiply(v)

from Accord.Math.Decompositions import SingularValueDecomposition

i = SingularValueDecomposition(I)

i.Diagonal

from Processing import *
size(500, 500)
background(0)
smooth()

points = []

def drawPoint():
    fill(255, 0, 0)
    noStroke()
    points.append([mouseX(), mouseY()])
    ellipse(mouseX(), mouseY(), 5, 5)
onMouseDragged += drawPoint
loop()

def clear():
    global points
    points = []
    background(0)
onKeyPressed += clear

points

data = Array.CreateInstance(float, len(points), len(points[0]))
for i in range(len(points)):
        for j in range(len(points[i])):
            data[i,j] = points[i][j]
print("# of points: ", data.Length)

from Accord.Statistics.Analysis import *
analysis = DescriptiveAnalysis(data)
ux,uy = analysis.Means

pca = PrincipalComponentAnalysis(data, AnalysisMethod.Center)

# Compute the Principal Component Analysis
pca.Compute()

stroke(0, 255,0)
strokeWeight(5)
for pc in pca.Components:
    x,y = pc.Eigenvector.Multiply(pc.Eigenvalue**0.5)
    line(ux - x, uy - y, ux + x, uy + y)

get()

for v in analysis.CovarianceMatrix:
        print(v)

from AForge.Imaging.Filters import *
from Accord.Imaging.Filters import *
from AForge.Imaging import Image
from Graphics import *

from System.Drawing import Bitmap
from System.Drawing.Imaging import PixelFormat

p = Picture("http://roboteducation.org/images/header_home.jpg")
image = p.toBitmap() #Image.Clone(p.toBitmap(), PixelFormat.Format24bppRgb)
calico.display(p)
# Create a new Gabor filter
filter = GaborFilter()

# Apply the filter
output = filter.Apply(image)
calico.display(Picture(output))

filter = GaussianBlur( 4, 11 )
output = filter.Apply( image )
calico.display(Picture(image))
calico.display(Picture(output))

import AForge.Imaging
dir(AForge.Imaging)

grayimage = Grayscale( 0.2125, 0.7154, 0.0721 ).Apply(image)
calico.display(Picture(grayimage))
filter = Threshold( 100 )
bwimage = filter.Apply( grayimage )
calico.display(Picture(bwimage))

from Accord.Imaging.Filters import RobinsonEdgeDetector
robinson = RobinsonEdgeDetector()
edges = robinson.Apply(image)
calico.display(Picture(edges))

from Accord.Imaging import SpeededUpRobustFeaturesDetector
from Accord.Imaging.Filters import FeaturesMarker

surf = SpeededUpRobustFeaturesDetector(.005, 5, 1)
points = surf.ProcessImage(image)
features = FeaturesMarker(points);
#new = features.Apply(grayimage)
#calico.display(Picture(new))
len(points)

import System
try:
    new = features.Apply(grayimage)
except System.Exception, e:
    print(e)

from Graphics import *
from Myro import  show
v = Picture(image)
w = Window(v.width, v.height)
w.draw(v)

for j in points:
    c = Circle((j.X, j.Y), 2)
    c.color = Color("red")
    w.draw(c)
calico.display(w)

from Accord.Vision.Detection import *
from Accord.Vision.Detection.Cascades import *
cascade = FaceHaarCascade()
detector = HaarObjectDetector(cascade, 15)
points = detector.ProcessFrame(image)

for j in points:
    c = Rectangle((j.X, j.Y), (j.X + j.Width, j.Y + j.Height))
    c.outline = Color("green")
    c.fill = None
    w.draw(c)
calico.display(w)