Expert Overview: Lillehammer vs Kongsvinger II

The upcoming match between Lillehammer and Kongsvinger II on September 30, 2025, at 17:00 promises to be a dynamic encounter. Historical data and current form suggest a game with high scoring potential, as evidenced by the average total goals predicted at 5.90. Both teams have demonstrated offensive capabilities, with Lillehammer averaging 2.60 goals scored per match and conceding an average of 3.60 goals. This indicates a potentially open game with multiple scoring opportunities for both sides.

Prediction Analysis

Over 0.5 Goals HT

The high probability of over 0.5 goals in the first half (97.10) suggests that both teams are likely to start aggressively, aiming to establish an early lead or respond to the opponent’s attacks.

Over 1.5 Goals

With a strong likelihood of over 1.5 goals (90.70), it is anticipated that both teams will maintain an attacking stance throughout the match, leading to multiple goals.

Both Teams Not To Score In 1st Half

The odds for both teams not scoring in the first half stand at 72.90, indicating a moderate chance of a goalless opening period despite the teams’ offensive trends.

Away Team Not To Score In 2nd Half

The prediction that the away team will not score in the second half (68.60) reflects Lillehammer’s potential defensive resilience as the game progresses.

Over 2.5 Goals

With odds at 68.70, it is likely that the match will feature more than two goals, aligning with the high-scoring nature expected from both teams.

Home Team To Score In 2nd Half

Lillehammer is favored to score in the second half (71.30), possibly capitalizing on their home advantage and momentum from earlier in the game.

Home Team To Win

The prediction for Lillehammer to win stands at a competitive rate of 66.90, reflecting their home advantage and recent form.

Home Team To Score In 1st Half

With odds at 58.50, Lillehammer is expected to find the net early, setting the tone for their attacking strategy from the outset.

Over 1.5 Goals HT

The likelihood of over 1.5 goals in the first half (57.70) supports expectations of an open and competitive start to the match.

Over 3.5 Goals

A prediction of over three and a half goals (59.40) further emphasizes the anticipated high-scoring nature of this encounter.

Both Teams Not To Score In 2nd Half

Odds at 62.90 suggest a moderate possibility that neither team will score in the second half, potentially due to tactical adjustments or fatigue.

Both Teams To Score

#include “ofApp.h”

//————————————————————–
void ofApp::setup(){
//Initialize OpenCV
cap.open(0);

//Check if video opened successfully
if (!cap.isOpened()) {
cout << "Error opening video stream or file" << endl;
return;
}

//Initialize Neural Network
loadNetwork();

//Set up GUI
gui.setup("Configuration");
gui.add(learningRate.set("Learning Rate",0.01f,0.f,1.f));
gui.add(momentum.set("Momentum",0.9f,0.f,1.f));

//Set up Video Capture
cap.set(CV_CAP_PROP_FRAME_WIDTH,320);
cap.set(CV_CAP_PROP_FRAME_HEIGHT,240);

}

//————————————————————–
void ofApp::update(){
//Check if camera is open
if(cap.isOpened()){
//Capture Frame
cap.read(frame);

//Convert frame from BGR to RGB format
cvtColor(frame,cvtColorFrame,CV_BGR2RGB);

//Reshape frame for network input
input = reshapeImage(cvtColorFrame);

//Get output from network
output = getOutput();

//Display Output as Images
displayOutput(output);

//Display frame
cv::Mat temp;
cvtColor(cvtColorFrame,temp,CV_RGB2GRAY);
grayImage = temp.clone();

frame.copyTo(originalFrame);
}
}

//————————————————————–
void ofApp::draw(){

}

//————————————————————–
void ofApp::keyPressed(int key){

}

//————————————————————–
void ofApp::keyReleased(int key){

}

//————————————————————–
void ofApp::mouseMoved(int x, int y ){

}

//————————————————————–
void ofApp::mouseDragged(int x, int y, int button){

}

//————————————————————–
void ofApp::mousePressed(int x, int y, int button){

}

//————————————————————–
void ofApp::mouseReleased(int x, int y, int button){

}

//————————————————————–
void ofApp::windowResized(int w, int h){

}

//————————————————————–
void ofApp::gotMessage(ofMessage msg){

}

//————————————————————–
void ofApp::dragEvent(ofDragInfo dragInfo){

}

//Load Neural Network
void ofApp::loadNetwork(){

neuralNet.load("neuralNetwork.xml");
}

//Get Output from Neural Network
cv::Mat ofApp::getOutput(){
cv::Mat output(1,CV_32FC64,(float*)neuralNet.forward(input));
return output;
}

//Display Output as Images
void ofApp::displayOutput(cv::Mat &output){

for (int i=0; i<output.cols; i++){
outputImage[i] = reshapeOutput(output.at(0,i));

cvtColor(outputImage[i],outputImage[i],CV_RGB2BGR);

outputImage[i].copyTo(outputFrames[i]);

ofPixels temp;

temp.setFromPixels(outputFrames[i].data,outputFrames[i].cols,outputFrames[i].rows,outputFrames[i].channels());

outputTextures[i].loadData(temp);

}

}

//Reshape Output Image for Display
cv::Mat ofApp::reshapeOutput(float value){

float newValue = value * outputScale + outputBias;

float resizedValue = newValue * resizedScale + resizedBias;

resizedValue = (resizedValue > maxValue ? maxValue : resizedValue);

resizedValue = (resizedValue <= minValue ? minValue : resizedValue);

cv::Mat newImage(resizedSize,resizedSize,CV_8UC4,cvScalar(0));

for (int i=0; i<resizedSize; i++){

for (int j=0; j maxValue ? maxValue : value);

colorValue = (colorValue <= minValue ? minValue : colorValue);

colorValue = pow(colorValue/255.f,.25f)*255.f;

unsigned char color[4] = {(unsigned char)colorValue,(unsigned char)colorValue,(unsigned char)colorValue,(unsigned char)colorValue};

newImage.at(i,j)[0] = color[0];

newImage.at(i,j)[1] = color[1];

newImage.at(i,j)[2] = color[2];

newImage.at(i,j)[3] = color[3];

if(value > .9f)
newImage.at(i,j)[0] = newImage.at(i,j)[1] =
newImage.at(i,j)[2] = newImage.at(i,j)[3] = (unsigned char)(255*value);

else if(value > .75f)
newImage.at(i,j)[0] = newImage.at(i,j)[1] =
newImage.at(i,j)[2] = newImage.at(i,j)[3] =
(unsigned char)(255*value*.75f);

else if(value > .50f)
newImage.at(i,j)[0] =
newImage.at(i,j)[2] =
newImage.at(i,j)[3] =
(unsigned char)(255*value*.50f);

else if(value > .25f)
newImage.at(i,j)[1] =
newImage.at(i,j)[2] =
newImage.at(i,j)[3] =
(unsigned char)(255*value*.25f);

else{
newImage.at(i,j)[0]=newImage.at(i,j)[1]=newImage.at(i,j)[2]=newImage.at(i,j)[3]=0;

}

}

}

return newImage;

}

//Reshape Input Image for Network Input
cv::Mat ofApp::reshapeImage(cv :: Mat &inputFrame){

cv :: Mat image(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));
cv :: Mat gray(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat edges(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat cannyEdges(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat closing(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat dilation(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat erosion(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat thresholded(resizeWidth,resizeHeight,CV_8UC1,cvScalar(0));

cv :: Mat contours;

vector<vector> contourList;

vector largestContour;

vector hierarchy;

vector momentsList;

Moments largestMoments;

Rect boundingRect;

Point center;

Point rotatedCenter;

float radius;

float angle;

int largestContourIndex;

vector contourPoints;

vector<vector> convexHull(contourList.size());

vector<vector> convexHullPoints(contourList.size());

vector<vector> convexHullReduced(contourList.size());

int convexHullPointCount;

float hullArea;

float contourArea;

float solidity;

float eccentricity;

vector<vector> approxPolyDP(contourList.size());

int approxPolyDPPointCount;

bool isCircle;

float minEnclosingCircleRadius;

float minEnclosingCircleX;

float minEnclosingCircleY;

float ellipseAxisMajor;

float ellipseAxisMinor;

double ellipseAngle;

double ellipseEccentricity;

vector ellipseFit(contourList.size());

RotatedRect rotatedEllipse;

vector< vector > contourSubdivisions(contourList.size());

int subdivisionCount;

float maxSubdivisionDistance;

float contourPerimeter;

float contourLengthRatio;

int histogramBinCount;

vector histogramBins(histogramBinCount);

vector normalizedHistogramBins(histogramBinCount);

float histogramEntropy;

Rect boundingBox;

RNG rng(12345);

cvtColor(inputFrame,image,CV_BGR2GRAY);

resize(image,image,inputSize);

GaussianBlur(image,image,(Size)(blurKernelSize.x+blurKernelSize.y*blurKernelSize.x),blurSigma);

Canny(image,cannyEdges,minCannyThreshold,maxCannyThreshold);

dilate(cannyEdges,dilation,dilateKernel);

erode(dilation,closing,erodeKernel);

erode(closing,closing,dilateKernel);

morphologyEx(closing,closing,MORPH_CLOSE,morphCloseKernel);

morphologyEx(closing,closing,MORPH_OPEN,morphOpenKernel);

morphologyEx(closing,closing,MORPH_GRADIENT,morphGradientKernel);

threshold(closing,closing,minThreshold,maxThreshold,THRESH_BINARY);

findContours(closing,
contours,
hierarchy,
CV_RETR_TREE,
CV_CHAIN_APPROX_SIMPLE,
Point(0,0));

for(unsigned int i=0;i<contours.size(); i++)
{
contourList.push_back(contours[i]);
momentsList.push_back(moments(contours[i]));
}

for(unsigned int i=0;i<momentsList.size(); i++)
{
if(momentsList[i].m00!=0)
{
momentsList[i].m10/=momentsList[i].m00;
momentsList[i].m01/=momentsList[i].m00;
}
else{
momentsList[i].m10=resizeWidth/2;
momentsList[i].m01=resizeHeight/2;
}
}

largestContourIndex=-1;

largestMoments.m00=-FLT_MAX;

for(unsigned int i=0;i=largestMoments.m00)
{
largestContourIndex=i;
largestMoments=momentsList[i];
}
}

if(largestContourIndex!=-1)
{
boundingRect=boundingRect(Mat(contourList[largestContourIndex]));

center=Point(largestMoments.m10,largestMoments.m01);

rotatedCenter=center;

radius=(boundingRect.width+boundingRect.height)/16;

rotate(center,
center,
Point(boundingRect.x+boundingRect.width/2,boundingRect.y+boundingRect.height/2),
PI/6);

approxPolyDP(Mat(contourList[largestContourIndex]),
approxPolyDP[largestContourIndex],
resizeWidth/100,
true);

convexHull(Mat(contourList[largestContourIndex]),
convexHull[largestContourIndex],
false);

convexHullPoints[largestContourIndex]=convexHull[largestContourIndex];

convexHullReduced[largestContourIndex]=convexHull[largestContourIndex];

convexHullPointCount=convexHullPoints[largestContourIndex].size();

hullArea=polyArea(convexHullReduced[largestContourIndex]);

contourArea=polyArea(contourList[largestContourIndex]);

solidity=hullArea!=0?(contourArea/hullArea):FLT_MAX;

Moments m= moments(Mat(convexHullReduced[largestContourIndex]));

double mu02=m.mu02,mu20=m.mu20,mu11=m.mu11;

eccentricity=sqrt((mu20-mu02)*(mu20-mu02)+4*mu11*mu11)/(mu20+mu02);

approxPolyDPPointCount=approxPolyDP[largestContourIndex].size();

isCircle=(approxPolyDPPointCount==5 &&
fabs(norm(Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-2])-Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-1]))-norm(Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-1])-Mat(approxPolyDP[largestContourIndex][0])))<resizeWidth/200 &&
fabs(norm(Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-2])-Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-1]))-norm(Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-1])-Mat(approxPolyDP[largestContourIndex][0])))<fabs(norm(Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-2])-Mat(approxPolyDP[largestContourIndex][approxPolyDPPointCount-1]))));

minEnclosingCircle(Center(minEnclosingCircleX,minEnclosingCircleY),minEnclosingCircleRadius,
Mat(contourList[largestContourIndex]));

fitEllipse(Mat(convexHullReduced[largestContourIndex]),rotatedEllipse);

ellipseAxisMajor=fmax(rotatedEllipse.size.width,
rotatedEllipse.size.height)/2;

ellipseAxisMinor=fmin(rotatedEllipse.size.width,
rotatedEllipse.size.height)/2;

ellipseAngle=rotatedEllipse.angle;

ellipseEccentricity=sqrt(ellipseAxisMajor*ellipseAxisMajor-ellipseAxisMinor*ellipseAxisMinor)/ellipseAxisMajor;

subdivisionCount=pow(convexHullPointCount,.75f)+rand()%6+6;

maxSubdivisionDistance=(resizeWidth+resizeHeight