/// <summary> /// Finds the closest trunk for a climbable tree /// </summary> /// <param name="trunkColor">color range defining a climbable tree trunk</param> /// <param name="trunk">returns a climbable tree trunk if found</param> /// <param name="minimumSize">not used</param> /// <returns>true if a climbable tree trunk is found</returns> private bool FindTreeTrunk(ColorFilter trunkColor, out Blob trunk, int minimumSize = 1, int maximumSize = int.MaxValue) { trunk = null; Screen.ReadWindow(); bool[,] objectPixels = Vision.ColorFilter(trunkColor); Vision.EraseClientUIFromMask(ref objectPixels); List <Blob> possibleTrunks = ImageProcessing.FindBlobs(objectPixels, false, MinTreeTrunkSize, MaxTreeTrunkSize); if (possibleTrunks.Count == 0) { return(false); } trunk = possibleTrunks[0]; double rectangularity; double mostRectangular = Geometry.Rectangularity(trunk); for (int i = 1; i < possibleTrunks.Count; i++) { rectangularity = Geometry.Rectangularity(possibleTrunks[i]); if (rectangularity > mostRectangular) { trunk = possibleTrunks[i]; mostRectangular = rectangularity; } } return(true); }
/// <summary> /// Looks for, picks up, and alchs a drop that matches a ColorRange /// </summary> /// <param name="screenDropArea"></param> /// <param name="referenceColor"></param> /// <param name="minimumSize">minimum number of pixels needed to </param> /// <returns>True if an item is found, picked up, and alched. May be false if no item is found or if there isn't inventory space to pick it up.</returns> private bool FindAndAlch(Color[,] screenDropArea, Point offset, ColorFilter referenceColor, int minimumSize) { bool[,] matchedPixels = Vision.ColorFilter(screenDropArea, referenceColor); Blob biggestBlob = ImageProcessing.BiggestBlob(matchedPixels); if (biggestBlob.Size < minimumSize) { return(false); //Nothing to grab. } Point blobCenter = biggestBlob.Center; if (AlchAlchables) { Inventory.GrabAndAlch(blobCenter.X + offset.X, blobCenter.Y + offset.Y); Inventory.OpenInventory(); } else { Inventory.Telegrab(blobCenter.X + offset.X, blobCenter.Y + offset.Y); Inventory.OpenInventory(); } return(true); }
/// <summary> /// Waits for the player to crawl through the drain pipe /// </summary> /// <returns>true if verified</returns> private bool VerifyPassedDrainPipe() { Stopwatch watch = new Stopwatch(); watch.Start(); List <Blob> drainPipes; bool[,] drain; Blob lowestBlob; while (watch.ElapsedMilliseconds < WAIT_FOR_VERIFICATION && !StopFlag) { Screen.ReadWindow(); drain = Vision.ColorFilter(DrainPipe); drainPipes = ImageProcessing.FindBlobs(drain, false, MinDrainPipeSize); if (drainPipes.Count > 0) { drainPipes.Sort(new BlobVerticalComparer()); lowestBlob = drainPipes[drainPipes.Count - 1]; if (lowestBlob.Center.Y > Screen.Center.Y) { return(true); } } } return(false); }
/// <summary> /// Finds the closest climbable tree /// </summary> /// <param name="treeColor">color range defining tree branches</param> /// <param name="tree">returns the tree blob if founf</param> /// <param name="minimumSize">not used</param> /// <returns>true if a set of branches is found</returns> private bool FindTreeBranches(out Blob tree, Point treeTrunk) { tree = null; Screen.ReadWindow(); bool[,] objectPixels = Vision.ColorFilter(TreeBranch); Vision.EraseClientUIFromMask(ref objectPixels); List <Blob> branches = ImageProcessing.FindBlobs(objectPixels, false, MinTreeBranchSize); if (branches.Count == 0) { return(false); } tree = branches[0]; double offset; double closestOffset = Geometry.DistanceBetweenPoints(treeTrunk, branches[0].GetBottom()); for (int i = 1; i < branches.Count; i++) { offset = Geometry.DistanceBetweenPoints(treeTrunk, branches[i].GetBottom()); if (offset < closestOffset) { tree = branches[i]; closestOffset = offset; } } return(true); }
/// <summary> /// Locates the closest unmined iron ore /// </summary> /// <param name="ironFilter"></param> /// <param name="foundObject"></param> /// <param name="minimumSize"></param> /// <returns>true if an ore rock is found</returns> protected bool LocateUnminedOre(ColorFilter ironFilter, out Blob foundObject, int minimumSize, int maximumSize = int.MaxValue) { Screen.ReadWindow(); bool[,] ironBoolArray = Vision.ColorFilter(ironFilter); foundObject = ImageProcessing.ClosestBlob(ironBoolArray, Screen.Center, minimumSize); return(foundObject != null); }
/// <summary> /// Looks for, picks up, and alchs a drop that matches a ColorRange /// </summary> /// <param name="screenDropArea"></param> /// <param name="referenceColor"></param> /// <param name="minimumSize">minimum number of pixels needed to </param> /// <returns>True if an item is found and telegrabbed. May be false if no item is found or if there isn't inventory space to pick it up.</returns> private bool FindAndGrab(Color[,] screenDropArea, Point offset, ColorFilter referenceColor, int minimumSize = 50) { bool[,] matchedPixels = Vision.ColorFilter(screenDropArea, referenceColor); Blob biggestBlob = ImageProcessing.BiggestBlob(matchedPixels); if (biggestBlob.Size > minimumSize) { Point blobCenter = biggestBlob.Center; Inventory.Telegrab(blobCenter.X + offset.X, blobCenter.Y + offset.Y); Inventory.OpenInventory(); return(true); } return(false); }
/// <summary> /// Locates the closest unmined iron ore /// </summary> /// <param name="ironFilter"></param> /// <param name="foundObject"></param> /// <param name="minimumSize"></param> /// <returns>true if an ore rock is found</returns> protected bool LocateFishingTile(ColorFilter fishFilter, out Blob foundObject, int minimumSize, int maximumSize = int.MaxValue) { foundObject = new Blob(); Screen.ReadWindow(); bool[,] fishBoolArray = Vision.ColorFilter(fishFilter); List <Blob> allMatches = ImageProcessing.FindBlobs(fishBoolArray); if (allMatches == null || allMatches.Count == 0) { return(false); } allMatches.Sort(new BlobProximityComparer(Screen.Center)); foundObject = Geometry.ClosestBlobToPoint(allMatches, Screen.Center); return(foundObject != null); }
/// <summary> /// Finds the leftmost drain pipe /// </summary> /// <param name="drainPipeColor"></param> /// <param name="drainPipe"></param> /// <param name="minimumSize"></param> /// <returns></returns> private bool LocateDrainPipe(ColorFilter drainPipeColor, out Blob drainPipe, int minimumSize = 1, int maximumSize = int.MaxValue) { drainPipe = null; Screen.ReadWindow(); bool[,] drains = Vision.ColorFilter(DrainPipe); List <Blob> drainPipes = ImageProcessing.FindBlobs(drains, false, MinDrainPipeSize); if (drainPipes.Count == 0) { return(false); } drainPipes.Sort(new BlobHorizontalComparer()); drainPipe = drainPipes[0]; return(true); }
/// <summary> /// This method detects whether or not the player is currently still fishing based on the distance of /// the closest fishing pole to the center /// /// </summary> /// <returns></returns> protected bool IsCurrentlyFishing() { Screen.ReadWindow(); bool[,] poleBoolArray = Vision.ColorFilter(FishingPoleFilter); Blob closestObject; closestObject = ImageProcessing.ClosestBlob(poleBoolArray, Screen.Center, 7); if (closestObject != null) { if (Geometry.DistanceBetweenPoints(closestObject.Center, Screen.Center) <= maxFishingPoleDistance) { return(true); } } return(false); }
/// <summary> /// Finds the possible kebbits. /// </summary> /// <returns>A list of kebbits in the order that they should be checked.</returns> protected List <Kebbit> LocateKebbits() { Screen.ReadWindow(); bool[,] blackSpotMatches = Vision.ColorFilter(Kebbit.KebbitBlackSpot); Vision.EraseClientUIFromMask(ref blackSpotMatches); List <Blob> blackSpots = ImageProcessing.FindBlobs(blackSpotMatches, false, 1, Screen.ArtifactArea(0.00002183)); //ex 1-11 (0.000000992-0.00001091) List <Cluster> kebbitLocations = ImageProcessing.ClusterBlobs(blackSpots, Screen.ArtifactLength(0.0349)); List <Kebbit> kebbits = new List <Kebbit>(); foreach (Cluster kebbitSpots in kebbitLocations) { kebbits.Add(new Kebbit(Screen, kebbitSpots, Screen.Center)); } return(kebbits); }
/// <summary> /// Looks for, picks up, and alchs a drop that matches a ColorRange /// </summary> /// <param name="screenDropArea"></param> /// <param name="referenceColor"></param> /// <param name="minimumSize">minimum number of pixels needed to </param> /// <returns>True if an item is found and telegrabbed. May be false if no item is found or if there isn't inventory space to pick it up.</returns> private bool FindAndGrabChaosRune(Color[,] screenDropArea, Point offset, ColorFilter referenceColor, int minimumSize = 50) { bool[,] matchedPixels = Vision.ColorFilter(screenDropArea, referenceColor); List <Blob> chaosRunes = ImageProcessing.FindBlobs(matchedPixels, true); for (int i = 0; i < Math.Min(10, chaosRunes.Count); i++) { if ((chaosRunes[i].Size > minimumSize) && chaosRunes[i].IsCircle(0.4)) { Point blobCenter = chaosRunes[i].Center; Inventory.Telegrab(blobCenter.X + offset.X, blobCenter.Y + offset.Y); Inventory.OpenInventory(); return(true); } } return(false); }
/// <summary> /// Locates the top of the frame of the middle cargo net of the closest group of three /// </summary> /// <param name="cargoNetFrameColor">defines the top of a cargo net color</param> /// <param name="cargoNet">returns the top of the middle cargo net</param> /// <param name="minimumSize">conservative size floor</param> /// <returns>true if a set of cargo nets is found</returns> private bool LocateMiddleCargoNet(ColorFilter cargoNetFrameColor, out Blob cargoNet, int minimumSize = 1, int maximumSize = int.MaxValue) { cargoNet = null; Screen.ReadWindow(); bool[,] cargoNetFrame = Vision.ColorFilter(CargoNet); Vision.EraseClientUIFromMask(ref cargoNetFrame); List <Blob> cargoNetFrames = ImageProcessing.FindBlobs(cargoNetFrame, false, MinCargoNetSize); if (cargoNetFrames.Count < 3) { return(false); } else { cargoNetFrames = ClosestFrameSet(cargoNetFrames); cargoNet = MiddleCargoNet(cargoNetFrames); return(true); } }
/// <summary> /// Estimates the target's fraction of its maximum hitpoints using OSBuddy's target hitpoints indicator /// </summary> /// <returns></returns> protected double TargetHitpointFraction() { if (!InCombat()) { return(double.MaxValue); } Screen.UpdateScreenshot(); Color[,] targetHitpoints = Vision.ScreenPiece(TARGET_HP_LEFT, TARGET_HP_RIGHT, TARGET_HP_TOP, TARGET_HP_BOTTOM); RGBHSBRange greenHPBar = RGBHSBRangeFactory.OSBuddyEnemyHitpointsGreen(); bool[,] greenHP = Vision.ColorFilter(targetHitpoints, greenHPBar); double greenWidth = ImageProcessing.BiggestBlob(greenHP).Width; RGBHSBRange redHPBar = RGBHSBRangeFactory.OSBuddyEnemyHitpointsRed(); bool[,] redHP = Vision.ColorFilter(targetHitpoints, redHPBar); double redWidth = ImageProcessing.BiggestBlob(redHP).Width; return(greenWidth / Numerical.NonZero(greenWidth + redWidth)); }
/// <summary> /// Finds the closest bank booth counter that matches a given color /// </summary> /// <param name="bankBoothColor">not used</param> /// <param name="bankBooth">returns the found bank booth blob</param> /// <returns>true if a bank booth is found</returns> internal bool LocateBankBooth(ColorFilter bankBoothColor, out Blob bankBooth) { bankBooth = null; if (!Screen.ReadWindow()) { return(false); } bool[,] bankBooths = Vision.ColorFilter(bankBoothColor); List <Blob> potentialBoothBlobs = ImageProcessing.FindBlobs(bankBooths, false, MinBankBoothSize, MaxBankBoothSize); List <Blob> booths = new List <Blob>(); foreach (Blob potentialBooth in potentialBoothBlobs) { if (Geometry.Rectangularity(potentialBooth) > 0.8) { booths.Add(potentialBooth); } } bankBooth = Blob.ClosestBlob(Screen.Center, booths); return(bankBooth != null); }
/// <summary> /// Creates a series of test images to visual how a color filter works /// </summary> /// <param name="filter">color filter to test</param> /// <param name="directory">directory in which to save test images</param> /// <param name="name">base name for test images</param> /// <param name="readWindow">Set to true to always read the window</param> protected void MaskTest(ColorFilter filter, string name = "maskTest", string directory = "C:\\Projects\\Roboport\\test_pictures\\mask_tests\\", bool readWindow = false) { Screen.MakeSureWindowHasBeenRead(); bool[,] thing = Vision.ColorFilter(filter); DebugUtilities.TestMask(Screen.Bitmap, Screen, filter, thing, directory, name); }