void BluetoothDeviceListItem::paintButton(Graphics &g, bool isMouseOverButton, bool isButtonDown) {
auto bounds = getLocalBounds();
auto inset = bounds.reduced(6, 4);
auto w = bounds.getWidth(), h = bounds.getHeight();
auto iconBounds = Rectangle<float>(w - h, h/5.0, h*0.6, h*0.6);
auto listOutline = Path();
listOutline.addRoundedRectangle(inset.toFloat(), 10.0f);
g.setColour(findColour(ListBox::ColourIds::backgroundColourId));
g.fillPath(listOutline);
if (device->connected) {
icons->checkIcon->setSize(h, h);
icons->checkIcon->drawWithin(g, iconBounds, RectanglePlacement::fillDestination, 1.0f);
}
// icons->arrowIcon->setSize(h, h);
// icons->arrowIcon->drawWithin(g, Rectangle<float>(w - (h/8), contentHeight + 8, contentHeight, contentHeight),
// RectanglePlacement::fillDestination, 1.0f);
g.setFont(Font(getLookAndFeel().getTypefaceForFont(Font())));
g.setFont(h * 0.5);
g.setColour(findColour(ListBox::ColourIds::textColourId));
g.drawText(getName(), inset.reduced(h * 0.2, 0), Justification::centredLeft, true);
}
AudioDataSet<T> AudioDataSet<T>::getVarianceReducedCopy(int numFeatures)
{
arma::Mat<T> dataNormalised(data);
PreProcessing::normalise(dataNormalised);
arma::Col<T> variances = arma::var(dataNormalised, 1, 1);
arma::uvec sorted = arma::sort_index(variances, 1);
arma::Mat<T> reducedData(numFeatures, data.n_cols);
std::vector<FeatureFramePair> reducedFeaturesUsed;
for (auto i = 0; i < numFeatures; ++i)
{
reducedData.row(i) = data.row(sorted[i]);
reducedFeaturesUsed.push_back(featuresUsed[sorted[i]]);
}
AudioDataSet reduced(numSounds, instancesPerSound, bufferSize,
stftFramesPerBuffer, numDelayedBuffers);
reduced.data = reducedData;
reduced.soundLabels = soundLabels;
reduced.featuresUsed = reducedFeaturesUsed;
return reduced;
}
vector<float> MPIDistribution::MPILayerReduceVariable(vector<float> data)
{
MPI_Comm* comm = MPIGetCommLayer();
vector<float> reduced(data.size());
MPI_Allreduce(&data[0],&reduced[0],data.size(),MPI_FLOAT,MPI_SUM,*comm);
return reduced;
}
void CpuRegistersComponent::resized()
{
auto working_area = getLocalBounds();
auto flags_area = working_area.removeFromRight(getWidth() / 3);
registers_list_.setBounds(working_area.reduced(1, 1));
registers_list_.setRowHeight(working_area.getHeight() / 6);
const auto flags_area_height = flags_area.getHeight();
zero_flag_toggle_.setBounds(flags_area.removeFromTop(flags_area_height / 4));
subtract_flag_toggle_.setBounds(flags_area.removeFromTop(flags_area_height / 4));
half_carry_flag_toggle_.setBounds(flags_area.removeFromTop(flags_area_height / 4));
carry_flag_toggle_.setBounds(flags_area);
}
float MatrixMath::det(const Matrix& Mat)
{
if( Mat._nRows == Mat._nCols )
{
if( Mat._nRows == 2 ) // 2x2 Matrix
{
float det;
det = Mat._matrix[0][0] * Mat._matrix[1][1] -
Mat._matrix[1][0] * Mat._matrix[0][1];
return det;
}
else if( Mat._nRows == 3 ) // 3x3 Matrix
{
float det;
MatrixMath dummy; //For Private Method.
det = dummy.Det3x3( Mat );
return det;
} else {
float part1= 0;
float part2= 0;
//Find +/- on First Row
for( int i = 0; i < Mat._nCols; i++)
{
Matrix reduced( Mat ); // Copy Original Matrix
Matrix::DeleteRow( reduced, 1); // Delete First Row
if( i%2 == 0 ) //Even Rows
{
Matrix::DeleteCol( reduced, i+1);
part1 += Mat._matrix[0][i] * MatrixMath::det(reduced);
}
else // Odd Rows
{
Matrix::DeleteCol( reduced, i+1);
part2 += Mat._matrix[0][i] * MatrixMath::det(reduced);
}
}
return part1 - part2;
}
}else{
printf("\n\nERROR:\nMatrix must be square Matrix @ MatrixMath::det");
}
}
int main(int argc, char **argv) {
int total, lower_bound, upper_bound, n, d;
for (d = 4; d <= atoi(argv[1]); d++) {
lower_bound = d / 3;
upper_bound = d / 2;
for (n = lower_bound; n <= upper_bound; n++) {
if (reduced(n, d) && frac_cmp(n, d, 1, 3) == 1 && frac_cmp(n, d, 1, 2) == -1) {
total++;
}
}
}
printf("Total: %d\n", total);
}
void ProjucerLookAndFeel::drawToggleButton (Graphics& g, ToggleButton& button, bool isMouseOverButton, bool isButtonDown)
{
ignoreUnused (isMouseOverButton, isButtonDown);
if (! button.isEnabled())
g.setOpacity (0.5f);
bool isTextEmpty = button.getButtonText().isEmpty();
bool isPropertyComponentChild = (dynamic_cast<BooleanPropertyComponent*> (button.getParentComponent()) != nullptr);
auto bounds = button.getLocalBounds();
auto sideLength = isPropertyComponentChild ? 25 : bounds.getHeight();
auto rectBounds = isTextEmpty ? bounds
: bounds.removeFromLeft (jmin (sideLength, bounds.getWidth() / 3));
rectBounds = rectBounds.withSizeKeepingCentre (sideLength, sideLength).reduced (4);
g.setColour (button.findColour (ToggleButton::tickDisabledColourId));
g.drawRoundedRectangle (rectBounds.toFloat(), 2.0f, 1.0f);
if (button.getToggleState())
{
g.setColour (button.findColour (ToggleButton::tickColourId));
const auto tick = getTickShape (0.75f);
g.fillPath (tick, tick.getTransformToScaleToFit (rectBounds.reduced (2).toFloat(), false));
}
if (! isTextEmpty)
{
bounds.removeFromLeft (5);
const auto fontSize = jmin (15.0f, button.getHeight() * 0.75f);
g.setFont (fontSize);
g.setColour (isPropertyComponentChild ? findColour (widgetTextColourId)
: button.findColour (ToggleButton::textColourId));
g.drawFittedText (button.getButtonText(), bounds, Justification::centredLeft, 2);
}
}
// pop data after each transfer to reduce memory usage
vector<vector<float> > MPIDistribution::MPILayerReduceVariable(vector<vector<float> > data)
{
MPI_Comm* comm = MPIGetCommLayer();
vector<vector<float> > reduced(data.size());//(data.size(),vector<float>(data[0].size()));
int size;
//cout<<data.size();cout.flush();
for(int i=0;i<data.size();i++)
{
vector<float> r(data[i].size());
size = data[i].size();
// Fix bug - should not need to use NETWORK_COMM_WORLD
MPI_Allreduce(&data[i][0],&r[0],size,MPI_FLOAT,MPI_SUM,NETWORK_COMM_WORLD);//*comm);
reduced[i] = r;
}
return reduced;
}
void ProjectContentComponent::resized()
{
auto r = getLocalBounds();
r.removeFromRight (10);
r.removeFromLeft (15);
r.removeFromBottom (40);
r.removeFromTop (5);
if (header != nullptr)
header->setBounds (r.removeFromTop (40));
r.removeFromTop (10);
auto sidebarArea = r.removeFromLeft (sidebarTabs.getWidth() != 0 ? sidebarTabs.getWidth()
: r.getWidth() / 4);
if (sidebarTabs.isVisible())
sidebarTabs.setBounds (sidebarArea);
if (resizerBar != nullptr)
resizerBar->setBounds (r.withWidth (4));
if (auto* h = dynamic_cast<HeaderComponent*> (header.get()))
{
h->sidebarTabsWidthChanged (sidebarTabs.getWidth());
r.removeFromRight (h->getUserButtonWidth());
}
if (contentView != nullptr)
{
if (fileNameLabel != nullptr && fileNameLabel->isVisible())
fileNameLabel->setBounds (r.removeFromTop (15));
contentView->setBounds (r);
}
if (logo != nullptr)
logo->setBounds (r.reduced (r.getWidth() / 6, r.getHeight() / 6));
}
void PowerPageComponent::resized() {
auto bounds = getLocalBounds();
powerSpinner->setBounds(0, 0, bounds.getWidth(), bounds.getHeight());
{
unsigned int number = 4;
for (int i = 0, j = 0; i < number; ++i) {
if (i > 0) verticalLayout.setItemLayout(j++, 0, -1, -1);
verticalLayout.setItemLayout(j++, 48, 48, 48);
}
Component *powerItems[] = { powerOffButton.get(), rebootButton.get(), sleepButton.get() };
auto b = bounds.reduced(10);
b.setLeft(70);
verticalLayout.layOutComponents(powerItems, 1, b.getX(), b.getY(), b.getWidth(),
b.getHeight(), true, true);
}
mainPage->setBounds(bounds);
powerOffButton->setBounds(bounds.getWidth()/7, 40, 350, 40);
sleepButton->setBounds(bounds.getWidth()/7, 90, 350, 40);
rebootButton->setBounds(bounds.getWidth()/7, 140, 350, 40);
felButton->setBounds(bounds.getWidth()/7, 190, 350, 40);
backButton->setBounds(bounds.getWidth()-60, bounds.getY(), 60, bounds.getHeight());
buildNameLabel->setBounds(bounds.getX(), bounds.getY(), bounds.getWidth(), 30);
buildNameLabel->setBoundsToFit(bounds.getX(), bounds.getY(), bounds.getWidth(), bounds.getHeight(), Justification::centredBottom, true);
rev->setBounds(bounds.getX(), bounds.getY(), 100, 30);
updateButton->setBounds(bounds.getX()+372, bounds.getY()+5, 100, 30);
int width = updateWindow->getWidth();
int height = updateWindow->getHeight();
int x = bounds.getWidth()/2-width/2;
int y = bounds.getHeight()/2-height/2;
updateWindow->setBounds(bounds.getX()+x, bounds.getY()+y, width, height);
}
void ConvolutionMatrixComponent::resized() {
auto matrix_height = optimum_routing_size * model.get_num_inputs();
auto matrix_width = optimum_routing_size * model.get_num_outputs();
auto input_width = getWidth() - matrix_width;
auto bounds = getLocalBounds();
auto left = bounds.removeFromLeft(input_width);
auto input_area = left.removeFromTop(matrix_height);
hrtf_component.setBounds(left.reduced(4, 4));
auto matrix_area = bounds.removeFromTop(matrix_height);
auto output_area = bounds;
for (auto i = 0u; i != routings.size(); ++i) {
auto y = i * optimum_routing_size;
for (auto j = 0u; j != routings[i].size(); ++j) {
auto x = j * optimum_routing_size;
routings[i][j]->setSize(optimum_routing_size, optimum_routing_size);
routings[i][j]->setTopLeftPosition(matrix_area.getTopLeft() +
juce::Point<int>(x, y));
}
}
for (auto i = 0u; i != inputs.size(); ++i) {
inputs[i]->setSize(input_area.getWidth(), optimum_routing_size);
inputs[i]->setTopLeftPosition(
input_area.getTopLeft() +
juce::Point<int>(0, i * optimum_routing_size));
}
for (auto i = 0u; i != outputs.size(); ++i) {
outputs[i]->setSize(optimum_routing_size, output_area.getHeight());
outputs[i]->setTopLeftPosition(
output_area.getTopLeft() +
juce::Point<int>(i * optimum_routing_size, 0));
}
}
//==========================================================================
// Class: Matrix
// Function: GetRowReduced
//
// Description: Performs row-reduction on copy of this until the matrix
// is upper-triangular.
//
// Input Arguments:
// None
//
// Output Arguments:
// None
//
// Return Value:
// Matrix& reference to this
//
//==========================================================================
Matrix Matrix::GetRowReduced(void) const
{
unsigned int curRow, pivotCol(0), pivotRow;
Matrix reduced(*this);
for (pivotRow = 0; pivotRow < GetMinimumDimension(); pivotRow++)
{
if (!IsZero(reduced.elements[pivotRow][pivotCol]))
{
for (curRow = pivotRow + 1; curRow < rows; curRow++)
{
if (!IsZero(reduced.elements[curRow][pivotCol]))
reduced.ZeroRowByScalingAndAdding(pivotRow, pivotCol, curRow);
}
}
else
{
for (curRow = pivotRow + 1; curRow < rows; curRow++)
{
if (!IsZero(reduced.elements[curRow][pivotCol]))
{
reduced.SwapRows(pivotRow, curRow);
pivotCol--;
break;
}
}
pivotRow--;
}
pivotCol++;
if (pivotCol >= columns)
break;
}
return reduced;
}
/** calculates upper bound on remaining subgraph, and heuristically generates a clique */
static
TCLIQUE_WEIGHT boundSubgraph(
TCLIQUE_GETNNODES((*getnnodes)), /**< user function to get the number of nodes */
TCLIQUE_GETWEIGHTS((*getweights)), /**< user function to get the node weights */
TCLIQUE_ISEDGE ((*isedge)), /**< user function to check for existence of an edge */
TCLIQUE_SELECTADJNODES((*selectadjnodes)), /**< user function to select adjacent edges */
TCLIQUE_GRAPH* tcliquegraph, /**< pointer to graph data structure */
BMS_CHKMEM* mem, /**< block memory */
int* buffer, /**< buffer of size nnodes */
int* V, /**< non-zero weighted nodes for branching */
int nV, /**< number of non-zero weighted nodes for branching */
NBC* gsd, /**< neighbour color information of all nodes */
TCLIQUE_Bool* iscolored, /**< coloring status of all nodes */
TCLIQUE_WEIGHT* apbound, /**< apriori bound of nodes for branching */
int* tmpcliquenodes, /**< buffer for storing the temporary clique */
int* ntmpcliquenodes, /**< pointer to store number of nodes of the temporary clique */
TCLIQUE_WEIGHT* tmpcliqueweight /**< pointer to store weight of the temporary clique */
)
{
assert(tmpcliqueweight != NULL);
/* check if we are in an easy case with at most 2 nodes left */
if( nV <= 2 )
{
/* get 1- or 2-clique and bounds without coloring */
reduced(getweights, isedge, tcliquegraph, V, nV, apbound, tmpcliquenodes, ntmpcliquenodes, tmpcliqueweight);
return *tmpcliqueweight;
}
else
{
/* color the graph induces by nodes of V to get an upper bound for the remaining subgraph */
return tcliqueColoring(getnnodes, getweights, selectadjnodes, tcliquegraph,
mem, buffer, V, nV, gsd, iscolored, apbound,
tmpcliquenodes, ntmpcliquenodes, tmpcliqueweight);
}
}
void ProjucerLookAndFeel::layoutFileBrowserComponent (FileBrowserComponent& browserComp,
DirectoryContentsDisplayComponent* fileListComponent,
FilePreviewComponent* previewComp,
ComboBox* currentPathBox,
TextEditor* filenameBox,
Button* goUpButton)
{
const auto sectionHeight = 22;
const auto buttonWidth = 50;
auto b = browserComp.getLocalBounds().reduced (20, 5);
auto topSlice = b.removeFromTop (sectionHeight);
auto bottomSlice = b.removeFromBottom (sectionHeight);
currentPathBox->setBounds (topSlice.removeFromLeft (topSlice.getWidth() - buttonWidth));
currentPathBox->setColour (ComboBox::backgroundColourId, findColour (backgroundColourId));
currentPathBox->setColour (ComboBox::textColourId, findColour (defaultTextColourId));
currentPathBox->setColour (ComboBox::arrowColourId, findColour (defaultTextColourId));
topSlice.removeFromLeft (6);
goUpButton->setBounds (topSlice);
bottomSlice.removeFromLeft (50);
filenameBox->setBounds (bottomSlice);
filenameBox->setColour (TextEditor::backgroundColourId, findColour (backgroundColourId));
filenameBox->setColour (TextEditor::textColourId, findColour (defaultTextColourId));
filenameBox->setColour (TextEditor::outlineColourId, findColour (defaultTextColourId));
filenameBox->applyFontToAllText (filenameBox->getFont());
if (previewComp != nullptr)
previewComp->setBounds (b.removeFromRight (b.getWidth() / 3));
if (auto listAsComp = dynamic_cast<Component*> (fileListComponent))
listAsComp->setBounds (b.reduced (0, 10));
}
void JsonDbReduceDefinition::updateObject(JsonDbObject before, JsonDbObject after, JsonDbUpdateList *changeList)
{
initScriptEngine();
QJsonValue beforeKeyValue = sourceKeyValue(before);
QJsonValue afterKeyValue = sourceKeyValue(after);
if (jsondbSettings->debug())
qDebug() << "JsonDbReduceDefinition::updateObject"
<< "beforeKeyValue" << beforeKeyValue
<< "afterKeyValue" << afterKeyValue;
if (!after.isEmpty() && !after.isDeleted() && !before.isEmpty() && (beforeKeyValue != afterKeyValue)) {
// do a subtract only on the before key
if (!beforeKeyValue.isUndefined())
updateObject(before, QJsonObject(), changeList);
// and then continue here with the add with the after key
before = QJsonObject();
}
const QJsonValue keyValue((after.isEmpty() || after.isDeleted()) ? beforeKeyValue : afterKeyValue);
if (keyValue.isUndefined())
return;
GetObjectsResult getObjectResponse = mTargetTable->getObjects(mTargetKeyName, keyValue, mTargetType);
if (!getObjectResponse.error.isNull())
setError(getObjectResponse.error.toString());
JsonDbObject previousObject;
QJsonValue previousValue(QJsonValue::Undefined);
JsonDbObjectList previousResults = getObjectResponse.data;
for (int k = 0; k < previousResults.size(); ++k) {
JsonDbObject previous = previousResults.at(k);
if (previous.value(QStringLiteral("_reduceUuid")).toString() == mUuid) {
previousObject = previous;
previousValue = previousObject;
break;
}
}
QJsonValue value = previousValue;
if (!before.isEmpty())
value = addObject(JsonDbReduceDefinition::Subtract, keyValue, value, before);
if (!after.isEmpty() && !after.isDeleted())
value = addObject(JsonDbReduceDefinition::Add, keyValue, value, after);
JsonDbObjectList objectsToUpdate;
// if we had a previous object to reduce
if (previousObject.contains(JsonDbString::kUuidStr)) {
// and now the value is undefined
if (value.isUndefined()) {
// then remove it
previousObject.markDeleted();
objectsToUpdate.append(previousObject);
} else {
//otherwise update it
JsonDbObject reduced(value.toObject());
reduced.insert(JsonDbString::kTypeStr, mTargetType);
reduced.insert(JsonDbString::kUuidStr,
previousObject.value(JsonDbString::kUuidStr));
reduced.insert(JsonDbString::kVersionStr,
previousObject.value(JsonDbString::kVersionStr));
reduced.insert(mTargetKeyName, keyValue);
reduced.insert(QStringLiteral("_reduceUuid"), mUuid);
objectsToUpdate.append(reduced);
}
} else if (!value.isUndefined()) {
// otherwise create the new object
JsonDbObject reduced(value.toObject());
reduced.insert(JsonDbString::kTypeStr, mTargetType);
reduced.insert(mTargetKeyName, keyValue);
reduced.insert(QStringLiteral("_reduceUuid"), mUuid);
objectsToUpdate.append(reduced);
}
JsonDbWriteResult res = mPartition->updateObjects(mOwner, objectsToUpdate, JsonDbPartition::ViewObject, changeList);
if (res.code != JsonDbError::NoError)
setError(QString::fromLatin1("Error executing add function: %1").arg(res.message));
}
int
main(void) {
reduced(0, 0.0, 0, 0.0, 0);
}
int main()
{
// Read input image
cv::Mat image = cv::imread("../images/boldt.jpg", 0);
if (!image.data)
return 0;
// Display the image
cv::namedWindow("Original Image");
cv::imshow("Original Image", image);
// Blur the image
cv::Mat result;
cv::GaussianBlur(image, result, cv::Size(5, 5), 1.5);
// Display the blurred image
cv::namedWindow("Gaussian filtered Image");
cv::imshow("Gaussian filtered Image", result);
// Get the gaussian kernel (1.5)
cv::Mat gauss = cv::getGaussianKernel(9, 1.5, CV_32F);
// Display kernel values
auto it = gauss.begin<float>();
auto itend = gauss.end<float>();
std::cout << "[";
for (; it != itend; ++it)
{
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the gaussian kernel (0.5)
gauss = cv::getGaussianKernel(9, 0.5, CV_32F);
// Display kernel values
it = gauss.begin<float>();
itend = gauss.end<float>();
std::cout << "[";
for (; it != itend; ++it)
{
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the gaussian kernel (2.5)
gauss = cv::getGaussianKernel(9, 2.5, CV_32F);
// Display kernel values
it = gauss.begin<float>();
itend = gauss.end<float>();
std::cout << "[";
for (; it != itend; ++it)
{
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the Deriv kernel (2.5)
cv::Mat kx, ky;
cv::getDerivKernels(kx, ky, 2, 2, 7, true);
// Display kernel values
auto kit = kx.begin<float>();
auto kitend = kx.end<float>();
std::cout << "[";
for (; kit != kitend; ++kit)
{
std::cout << *kit << " ";
}
std::cout << "]" << std::endl;
// Blur the image with a mean filter
cv::blur(image, result, cv::Size(5, 5));
// Display the blurred image
cv::namedWindow("Mean filtered Image");
cv::imshow("Mean filtered Image", result);
// Read input image with salt&pepper noise
image = cv::imread("../images/salted.bmp", 0);
if (!image.data)
return 0;
// Display the S&P image
cv::namedWindow("S&P Image");
cv::imshow("S&P Image", image);
// Blur the image with a mean filter
cv::blur(image, result, cv::Size(5, 5));
// Display the blurred image
cv::namedWindow("Mean filtered S&P Image");
cv::imshow("Mean filtered S&P Image", result);
// Applying a median filter
cv::medianBlur(image, result, 5);
// Display the blurred image
cv::namedWindow("Median filtered S&P Image");
cv::imshow("Median filtered S&P Image", result);
// Reduce by 4 the size of the image (the wrong way)
image = cv::imread("../images/boldt.jpg", 0);
cv::Mat reduced(image.rows / 2, image.cols / 2, CV_8U);
for (int i = 0; i < reduced.rows; i++)
for (int j = 0; j < reduced.cols; j++)
reduced.at<uchar>(i, j) = image.at<uchar>(i * 2, j * 2);
// Display the reduced image
cv::namedWindow("Badly reduced Image");
cv::imshow("Badly reduced Image", reduced);
cv::waitKey();
return 0;
}
int main()
{
// Read input image,imread flag = 0 表示读入灰度图像
cv::Mat image= cv::imread("D:\\OpenCV demos\\images\\boldt.jpg",0);
if (!image.data)
return 0;
// 显示原始图像
cv::namedWindow("Original Image");
cv::imshow("Original Image",image);
// 高斯滤波器，高斯模糊，用周围像素加权值代替中间的值，属于低通滤波器，平缓灰度变化过快的地方
cv::Mat result;
cv::GaussianBlur(image,result,cv::Size(5,5),1.5);
cv::namedWindow("Gaussian filtered Image");
cv::imshow("Gaussian filtered Image",result);
// Get the gaussian kernel (1.5)
cv::Mat gauss= cv::getGaussianKernel(9,1.5,CV_32F);
// Display kernel values
cv::Mat_<float>::const_iterator it= gauss.begin<float>();
cv::Mat_<float>::const_iterator itend= gauss.end<float>();
std::cout << "[";
for ( ; it!= itend; ++it) {
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the gaussian kernel (0.5)
gauss= cv::getGaussianKernel(9,0.5,CV_32F);
// Display kernel values
it= gauss.begin<float>();
itend= gauss.end<float>();
std::cout << "[";
for ( ; it!= itend; ++it) {
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the gaussian kernel (2.5)
gauss= cv::getGaussianKernel(9,2.5,CV_32F);
// Display kernel values
it= gauss.begin<float>();
itend= gauss.end<float>();
std::cout << "[";
for ( ; it!= itend; ++it) {
std::cout << *it << " ";
}
std::cout << "]" << std::endl;
// Get the Deriv kernel (2.5)
cv::Mat kx, ky;
cv::getDerivKernels(kx,ky,2,2,7,true);
// Display kernel values
cv::Mat_<float>::const_iterator kit= kx.begin<float>();
cv::Mat_<float>::const_iterator kitend= kx.end<float>();
std::cout << "[";
for ( ; kit!= kitend; ++kit) {
std::cout << *kit << " ";
}
std::cout << "]" << std::endl;
// 均值滤波器
cv::blur(image,result,cv::Size(5,5));
//对普通图的效果
cv::namedWindow("Mean filtered Image");
cv::imshow("Mean filtered Image",result);
// 对椒盐图的效果
image= cv::imread("D:\\OpenCV demos\\images\\salted.jpg",0);
if (!image.data)
return 0;
// 显示椒盐图
cv::namedWindow("S&P Image");
cv::imshow("S&P Image",image);
// 箱式滤波器，均值滤波器
cv::blur(image,result,cv::Size(5,5));
// 显示处理后的椒盐图
cv::namedWindow("Mean filtered S&P Image");
cv::imshow("Mean filtered S&P Image",result);
// 中值滤波器
cv::medianBlur(image,result,5);
// Display the blurred image
cv::namedWindow("Median filtered S&P Image");
cv::imshow("Median filtered S&P Image",result);
//减少图像信息，去行去列，后增大但不能填补原先的信息
image= cv::imread("D:\\OpenCV demos\\images\\boldt.jpg",0);
cv::Mat reduced(image.rows/2,image.cols/2,CV_8U);
for (int i=0; i<reduced.rows; i++)
for (int j=0; j<reduced.cols; j++)
reduced.at<uchar>(i,j)= image.at<uchar>(i*2,j*2);
// Display the reduced image
cv::namedWindow("Badly reduced Image");
cv::imshow("Badly reduced Image",reduced);
cv::waitKey();
return 0;
}
natural pca::reduced(real percent) const {
return reduced(dev(), percent);
}
