עיצוב מפות חדש יתווסף בקרוב לפלטפורמה של מפות Google. העדכון הזה בסגנון המפה כולל לוח צבעים חדש שמוגדר כברירת מחדל ושיפורים בחוויית השימוש במפות ובנוחות השימוש. כל סגנונות המפה יעודכנו באופן אוטומטי במרץ 2025. אפשר לקרוא מידע נוסף על זמינות ועל האפשרות להצטרף בשלב מוקדם יותר במאמר בנושא סגנון מפה חדש לפלטפורמה של מפות Google.

דף זה תורגם על ידי Cloud Translation API.

צורות

בחירת פלטפורמה: Android iOS JavaScript

מפה עם קו פוליגוני אדום מלא

ב-Google Maps API ל-Android יש כמה דרכים פשוטות להוספת צורות למפות שלך כדי להתאים אותן אישית עבור האפליקציה שלך.

Polyline הוא סדרה של קטעי קו מחוברים שיכולים יוצרות כל צורה שרוצים, ואפשר להשתמש בה כדי לסמן נתיבים ומסלולים במפה.
Polygon היא צורה שמוגדרת בגבולות שאפשר להשתמש בה כדי לסמן אזורים במפה.
Circle הוא תחזית מדויקת של מעגל מבחינה גיאוגרפית על פני כדור הארץ שמצוינים במפה.

עבור כל הצורות האלה, תוכלו להתאים אישית את המראה שלהן על ידי שינוי מספר המאפיינים.

דוגמאות קוד

המדריך בנושא הוספה פוליגונים וקווים פוליגוניים לייצוג שטחים ומסלולים כולל את כל הקוד לאפליקציה פשוטה ל-Android.

בנוסף, מאגר ApiDemos ב-GitHub כולל דוגמאות שמדגימות את השימוש בצורות ואת התכונות שלהן:

CircleDemoActivity (Java / Kotlin): מעגל
PolygonDemoActivity (Java / Kotlin): פוליגון
PolylineDemoActivity (Java / Kotlin): Polyline

קווים פוליגוניים

המחלקה Polyline מגדירה קבוצה של קו מחובר פלחים במפה. אובייקט Polyline מורכב מקבוצה של LatLng מיקומים, ויוצרת סדרה של מקטעי קו מחברים את המיקומים האלה לפי הסדר.

הסרטון הזה נותן רעיונות שיעזרו למשתמשים להגיע למקום שאליו הם צריכים להגיע, באמצעות קווים פוליגוניים כדי לשרטט נתיב במפה.

כדי ליצור קו פוליגוני, קודם צריך ליצור PolylineOptions של האובייקט ולהוסיף לו נקודות. נקודות מייצגות נקודה על פני כדור הארץ, ומבוטאים כאובייקט LatLng. שרטטו קטעי קו בין נקודות לפי הסדר שבו אתם מוסיפים אותן אובייקט PolylineOptions.

כדי להוסיף נקודות לאובייקט PolylineOptions, קוראים לפונקציה PolylineOptions.add(). שימו לב שהשיטה הזו לוקחת מספר משתנה של פרמטרים, כדי שתוכלו הוספת מספר נקודות בכל פעם (אפשר גם להתקשר למספר PolylineOptions.addAll(Iterable<LatLng>)) אם הנקודות כבר מופיעות ברשימה).

לאחר מכן אפשר להוסיף את הקו הפוליגוני למפה באמצעות קריאה GoogleMap.addPolyline(PolylineOptions) הפונקציה מחזירה אובייקט Polyline שבאמצעותו אפשר לשנות את הקו הפוליגוני מאוחר יותר.

קטע הקוד הבא ממחיש איך להוסיף מלבן למפה:

Kotlin



// Instantiates a new Polyline object and adds points to define a rectangle
val polylineOptions = PolylineOptions()
    .add(LatLng(37.35, -122.0))
    .add(LatLng(37.45, -122.0)) // North of the previous point, but at the same longitude
    .add(LatLng(37.45, -122.2)) // Same latitude, and 30km to the west
    .add(LatLng(37.35, -122.2)) // Same longitude, and 16km to the south
    .add(LatLng(37.35, -122.0)) // Closes the polyline.

// Get back the mutable Polyline
val polyline = map.addPolyline(polylineOptions)

Java


// Instantiates a new Polyline object and adds points to define a rectangle
PolylineOptions polylineOptions = new PolylineOptions()
    .add(new LatLng(37.35, -122.0))
    .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
    .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
    .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
    .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Get back the mutable Polyline
Polyline polyline = map.addPolyline(polylineOptions);

המלבן מופיע במפה באופן הבא:

מפה עם קו פוליגוני של מלבן

כדי לשנות את הצורה של הקו הפוליגוני לאחר הוספתו, אפשר לקרוא Polyline.setPoints() ומספקים רשימה חדשה של נקודות לקו הפוליגוני.

אפשר להתאים אישית את המראה של הקו הפוליגוני לפני שמוסיפים אותו למפה ואחרי שהוא נוסף למפה. צפייה בקטע שעוסק ב- כדי לקבל פרטים נוספים, תוכלו להתאים אישית את המראה בהמשך.

התאמה אישית של קו פוליגוני

יש כמה דרכים להתאים אישית את המראה של קווים פוליגוניים:

קווים פוליגוניים צבעוניים מגדירים פלחים של קווים פוליגוניים לצבעים שונים.
קווים פוליגוניים של צבעים צובעים קו פוליגוני באמצעות הדרגתיות של שני צבעים.
קווים פוליגוניים מוטמעים בסגנון פוליגונים באמצעות מפות סיביות חוזרות.

כדי להשתמש בהתאמות האישיות של Polyline, צריך להשתמש ב-SDK של מפות Google ל-Android בגרסה 18.1.0 ואילך יש להשתמש בגרסה העדכנית ביותר של SDK של מפות ל-Android.

יצירת קו פוליגוני צבעוני

מפה עם קו פוליגוני צבעוני

ניתן להשתמש בטווחים כדי לצבוע בנפרד קטעים של קו פוליגוני, על ידי יצירת StyleSpan אובייקטים, והוספתם אל PolylineOptions באמצעות addSpan() או addSpans(). כברירת מחדל, כל פריט במערך יקבע את הצבע של קטע הקו המתאים. בדוגמה הבאה מוצג פלח של ההגדרה צבעים כדי ליצור קו פוליגוני עם מקטעי אדום וירוק:

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(StyleSpan(Color.RED))
        .addSpan(StyleSpan(Color.GREEN))
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(Color.RED))
        .addSpan(new StyleSpan(Color.GREEN)));

יצירת קו פוליגוני הדרגתי

מפה עם קו פוליגוני הדרגתי

ניתן להגדיר הדרגתי על ידי ציון שני 32 סיביות אלפא-אדום-ירוק-כחול (ARGB) מספרים שלמים, כדי לציין את צבעי ההתחלה והסיום של הקו. הגדרה באובייקט האפשרויות של הצורה, באמצעות קריאה ל-PolylineOptions.addSpan(). הדוגמה הבאה מציגה יצירת קו פוליגוני הדרגתי של צבע אדום לצהוב מ- גן החיות וודלנד פארק שקירקלנד, וושינגטון

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(
            StyleSpan(
                StrokeStyle.gradientBuilder(
                    Color.RED,
                    Color.YELLOW
                ).build()
            )
        )
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(StrokeStyle.gradientBuilder(Color.RED, Color.YELLOW).build())));

יצירת קו פוליגוני עם חותמת

מפה עם קו פוליגוני עם חותמת

ניתן להגדיר את המראה של קו פוליגוני למרקם חוזר של מפת סיביות (bitmap). לבצע הזה, יוצרים StampStyle של TextureStyle ואז מגדירים את המאפיין הזה לאובייקט האפשרויות של הצורה, על ידי קריאה ל-PolylineOptions.addSpan() כמו שמוצג כאן:

Kotlin



val stampStyle =
    TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build()
val span = StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build())
map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(span)
)

Java


StampStyle stampStyle =
        TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build();
StyleSpan span = new StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build());
map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(span));

אירועים של קו פוליגוני

כברירת מחדל, אי אפשר ללחוץ על קווים פוליגוניים. אפשר להפעיל ולהשבית את קליקביליות באמצעות הפעלה של Polyline.setClickable(boolean).

שימוש ב-OnPolylineClickListener כדי להקשיב לאירועים לוחצים בקו פוליגוני שניתן ללחוץ עליו. כדי להגדיר את ה-listener הזה במפה: קוראים לפונקציה GoogleMap.setOnPolylineClickListener(OnPolylineClickListener). כשמשתמש ילחץ על קו פוליגוני, תקבלו התקשרות חזרה onPolylineClick(Polyline).

פוליגונים

Polygon אובייקטים דומים ל-Polyline כי הם מכילים סדרה של קואורדינטות ברצף. עם זאת, במקום להיות פתוחים, פוליגונים מיועדים להגדיר אזורים בתוך לולאה סגורה שהחלק הפנימי שלה מלא.

אפשר להוסיף Polygon למפה באותה דרך שבה מוסיפים Polyline. קודם כול יוצרים אובייקט PolygonOptions ולהוסיף לו כמה נקודות. הנקודות האלה יהוו את קווי המתאר של הפוליגון. לאחר מכן מוסיפים את הפוליגון למפה באמצעות שליחת קריאה GoogleMap.addPolygon(PolygonOptions) שיקרו מחזירה אובייקט Polygon.

קטע הקוד הבא מוסיף מלבן למפה.

Kotlin



// Instantiates a new Polygon object and adds points to define a rectangle
val rectOptions = PolygonOptions()
    .add(
        LatLng(37.35, -122.0),
        LatLng(37.45, -122.0),
        LatLng(37.45, -122.2),
        LatLng(37.35, -122.2),
        LatLng(37.35, -122.0)
    )

// Get back the mutable Polygon
val polygon = map.addPolygon(rectOptions)

Java


// Instantiates a new Polygon object and adds points to define a rectangle
PolygonOptions polygonOptions = new PolygonOptions()
    .add(new LatLng(37.35, -122.0),
        new LatLng(37.45, -122.0),
        new LatLng(37.45, -122.2),
        new LatLng(37.35, -122.2),
        new LatLng(37.35, -122.0));

// Get back the mutable Polygon
Polygon polygon = map.addPolygon(polygonOptions);

כדי לשנות את הצורה של הפוליגון אחרי שנוסף, אפשר לבצע קריאה Polygon.setPoints() ומספקים רשימה חדשה של נקודות למתאר של המצולע.

אפשר להתאים אישית את המראה של הפוליגון לפני שמוסיפים אותו. למפה ואחרי שהוא נוסף למפה. צפייה בקטע שעוסק ב- כדי לקבל פרטים נוספים, תוכלו להתאים אישית את המראה בהמשך.

השלמה אוטומטית בפוליגון

הפוליגון בדוגמה שלמעלה מכיל חמש קואורדינטות, אך שימו לב לכך הקואורדינטה הראשונה והאחרונה זהות, ומגדיר את הלולאה. עם זאת, בפועל, מכיוון שפוליגונים מגדירים אזורים סגורים, לא צריך להגדיר את הקואורדינטה האחרונה הזו. אם הקואורדינטה האחרונה שונה מהקואורדינטה הראשונה, ממשק ה-API "ייסגר" באופן אוטומטי את הפוליגון באמצעות חיבור הקואורדינטה הראשונה הוא הסוף של רצף הקואורדינטות.

שני הפוליגונים הבאים הם זהים, polygon.getPoints() לכל אחד מהם יחזיר את כל 4 הנקודות.

Kotlin



val polygon1 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(0.0, 0.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)
val polygon2 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)

Java


Polygon polygon1 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(0, 0))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Polygon polygon2 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

יצירת פוליגון חלול

ניתן לשלב מספר נתיבים באובייקט Polygon אחד כדי ליצור צורות מורכבות, כמו טבעות ממולאות או 'דונאטס' (כאשר פוליגונים מופיעים בתוך הפוליגון כ"איים"). צורות מורכבות הן תמיד של נתיבים מרובים ופשוטים יותר.

יש להגדיר שני נתיבים באותו אזור. האזור הגדול מבין שני האזורים מגדיר את שטח המילוי, והוא פוליגון פשוט ללא אפשרויות נוספות. לאחר מכן, מעבירים נתיב שני ל-method addHole(). כשהערך השני הוא 'קטן', הנתיב המלא מוקף בנתיב הגדול יותר, הוא ייראה כאילו חלק מהנתיב הוסר. אם החור חוצה את קווי המצולע, הפוליגון יוצג ללא מילוי.

קטע הקוד שבהמשך ייצור מלבן יחיד עם מלבן קטן יותר חור.

Kotlin



val hole = listOf(
    LatLng(1.0, 1.0),
    LatLng(1.0, 2.0),
    LatLng(2.0, 2.0),
    LatLng(2.0, 1.0),
    LatLng(1.0, 1.0)
)
val hollowPolygon = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(3.0, 0.0),
            LatLng(0.0, 0.0)
        )
        .addHole(hole)
        .fillColor(Color.BLUE)
)

Java


List<LatLng> hole = Arrays.asList(new LatLng(1, 1),
    new LatLng(1, 2),
    new LatLng(2, 2),
    new LatLng(2, 1),
    new LatLng(1, 1));
Polygon hollowPolygon = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(3, 0),
        new LatLng(0, 0))
    .addHole(hole)
    .fillColor(Color.BLUE));

הפוליגון החלול מופיע במפה באופן הבא:

מפה עם קו פוליגוני מלבני חלול

אירועי פוליגון

כברירת מחדל, לא ניתן ללחוץ על פוליגונים. אפשר להפעיל ולהשבית את קליקביליות באמצעות קריאה אל Polygon.setClickable(boolean).

שימוש ב-OnPolygonClickListener כדי להקשיב לאירועים בפוליגון שניתן ללחוץ עליו. כדי להגדיר את ה-listener הזה במפה: קוראים לפונקציה GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). כשמשתמש ילחץ על פוליגון, תקבלו התקשרות חזרה onPolygonClick(Polygon).

מעגלים

מפה עם מעגל

בנוסף למחלקה כללית ב-Polygon, ה-API של מפות Google כולל גם של Circle אובייקטים, כדי לפשט את הבנייה שלהם.

כדי ליצור מעגל, צריך לציין את שני המאפיינים הבאים:

center בתור LatLng.
radius במטרים.

לאחר מכן מגדירים מעגל בתור קבוצת כל הנקודות על פני כדור הארץ שנמצאים במרחק של radius מטרים מהcenter הנתון. בזכות היטל Mercator שבו נעשה שימוש על ידי API של מפות Google יוצר כדור על פני משטח ישר, עיגול כמעט מושלם במפה כשהוא ממוקם ליד קו המשווה, והוא ייראה יותר ויותר לא מעגלי (על המסך) העיגול מתרחק מקו המשווה.

כדי לשנות את הצורה של העיגול אחרי הוספת העיגול, אפשר להתקשר Circle.setRadius() או Circle.setCenter() ומספקים ערכים חדשים.

אפשר להתאים אישית את המראה של המעגל לפני שמוסיפים אותו למפה ואחרי שהוא נוסף למפה. צפייה בקטע שעוסק ב- כדי לקבל פרטים נוספים, תוכלו להתאים אישית את המראה בהמשך.

קטע הקוד הבא מוסיף עיגול למפה על ידי בניית אובייקט CircleOptions והתקשרות GoogleMap.addCircle(CircleOptions):

Kotlin



// Instantiates a new CircleOptions object and defines the center and radius
val circleOptions = CircleOptions()
    .center(LatLng(37.4, -122.1))
    .radius(1000.0) // In meters

// Get back the mutable Circle
val circle = map.addCircle(circleOptions)

Java


// Instantiates a new CircleOptions object and defines the center and radius
CircleOptions circleOptions = new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000); // In meters

// Get back the mutable Circle
Circle circle = map.addCircle(circleOptions);

אירועים של מעגלים

כברירת מחדל, לא ניתן ללחוץ על מעגלים. אפשר להפעיל ולהשבית את קליקביליות על ידי התקשרות אל GoogleMap.addCircle() באמצעות CircleOptions.clickable(boolean), או בטלפון Circle.setClickable(boolean).

שימוש ב-OnCircleClickListener כדי להקשיב לאירועים לוחצים על מעגל קליקבילי. כדי להגדיר את ה-listener הזה במפה: קוראים לפונקציה GoogleMap.setOnCircleClickListener(OnCircleClickListener).

כאשר משתמש לוחץ על מעגל, תקבל קריאה חוזרת של onCircleClick(Circle), כפי שמוצג בדוגמת הקוד הבאה:

Kotlin



val circle = map.addCircle(
    CircleOptions()
        .center(LatLng(37.4, -122.1))
        .radius(1000.0)
        .strokeWidth(10f)
        .strokeColor(Color.GREEN)
        .fillColor(Color.argb(128, 255, 0, 0))
        .clickable(true)
)
map.setOnCircleClickListener {
    // Flip the r, g and b components of the circle's stroke color.
    val strokeColor = it.strokeColor xor 0x00ffffff
    it.strokeColor = strokeColor
}

Java


Circle circle = map.addCircle(new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000)
    .strokeWidth(10)
    .strokeColor(Color.GREEN)
    .fillColor(Color.argb(128, 255, 0, 0))
    .clickable(true));

map.setOnCircleClickListener(new GoogleMap.OnCircleClickListener() {
    @Override
    public void onCircleClick(Circle circle) {
        // Flip the r, g and b components of the circle's stroke color.
        int strokeColor = circle.getStrokeColor() ^ 0x00ffffff;
        circle.setStrokeColor(strokeColor);
    }
});

התאמה אישית של תצוגות

אפשר לשנות את המראה של צורה לפני שהוא נוסף למפה (על ידי ציון הנכס הרצוי באובייקט האפשרויות) או לאחר שהוא נוסף למפה. המנצחים הם נחשפות גם בכל הנכסים, כך שאפשר לגשת בקלות במצב של הצורה.

קטע הקוד הבא מוסיף קו פוליגוני כחול ועבה עם פלחים גיאודזיים מתוך מלבורן לפרת'. הקטעים הבאים יסבירו את המאפיינים האלה מפורט.

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
        .width(25f)
        .color(Color.BLUE)
        .geodesic(true)
)

Java


Polyline polyline = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

המפה תיראה כך:

מפה עם קו פוליגוני ממלבורן לפרת'

הערה: אפשר להחיל את רוב ההגדרות האלה על כל אחת מהצורות המתוארות, ייתכן שחלק מהתכונות מתאימות לצורות מסוימות (למשל, לקו מרובה אין צבע מילוי כי הוא לא יכול להיות בעל צבע מילוי שאין בו פנים).

צבע משיכה

צבע הקו הוא מספר שלם בצבע אלפא-אדום-ירוק-כחול (ARGB) של 32 סיביות, שמציין את את האטימות והצבע של קו הצורה. הגדרת המאפיין הזה אובייקט אפשרויות באמצעות קריאה ל-*Options.strokeColor() (או PolylineOptions.color() במקרה של קו פוליגוני). אם לא צוין, צבע הקו שמוגדר כברירת מחדל הוא שחור (Color.BLACK).

לאחר הוספת הצורה למפה, ניתן לגשת לצבע הקו באמצעות קריאה אל getStrokeColor() (או getColor() לקו פוליגוני) וניתן לשנות אותו התקשרות אל setStrokeColor() (setColor() for a polyline).

צבע מילוי

צבע המילוי חל רק על פוליגונים ומעגלים. היא לא חלה על קווים פוליגוניים כי אין להם פנים מוגדרות. בפוליגון, האזורים החורים שלו אינם חלק מהחלק הפנימי של המצולע, אם הוגדר צבע מילוי.

צבע המילוי הוא מספר שלם בצבע אלפא-אדום-ירוק-כחול (ARGB) של 32 סיביות, שמציין את השקיפות והצבע של החלק הפנימי של הצורה. הגדרת הנכס הזה לאובייקט של האפשרויות של הצורה באמצעות קריאה ל-*Options.fillColor(). אם לא צוין, צבע הקו שמוגדר כברירת מחדל הוא שקוף (Color.TRANSPARENT).

לאחר הוספת הצורה למפה, ניתן לגשת לצבע המילוי באמצעות מתקשר אל getFillColor() וייתכן שהוא ישתנה באמצעות חיוג אל setFillColor().

רוחב משיכה

רוחב קו הקו, כצף בפיקסלים (px). הרוחב לא משתנה כאשר המפה מוגדלת (כלומר, תופיע צורה אותו רוחב קווים בכל רמות הזום). הגדרת המאפיין הזה אובייקט של Option באמצעות *Options.strokeWidth() (או PolylineOptions.width() לקו פוליגוני). אם לא צוין קו, קו ברירת המחדל הוא 10 פיקסלים.

לאחר הוספת הצורה למפה, ניתן לגשת לרוחב הקו באמצעות קריאה אל getStrokeWidth() (או getWidth() לקו פוליגוני) וניתן לשנות אותו התקשרות אל setStrokeWidth() (setWidth() for a polyline).

קו ביטול נעילה

תבנית הקווים שמוגדרת כברירת מחדל היא קו רציף לקווים פוליגוניים ולקווי מתאר של פוליגונים ומעגלים. ניתן לציין דפוס קווים מותאם אישית של PatternItem, כאשר כל פריט הוא מקף, נקודה או פער.

הדוגמה הבאה מגדירה את הדפוס של קו פוליגוני רצף של נקודה, ואחריו פער באורך 20 פיקסלים, קו מפריד באורך 30 פיקסלים ופער נוסף של 20 פיקסלים.

Kotlin



val pattern = listOf(
    Dot(), Gap(20F), Dash(30F), Gap(20F)
)
polyline.pattern = pattern

Java


List<PatternItem> pattern = Arrays.asList(
    new Dot(), new Gap(20), new Dash(30), new Gap(20));
polyline.setPattern(pattern);

הדפוס חוזר לאורך הקו, החל בפריט דוגמת העיצוב הראשון הקודקוד הראשון שצוין לצורה.

סוגי החיבורים

לקווים פוליגוניים ולקווי מתאר של מצולעים, ניתן לציין שיפוע או עגול JointType כדי להחליף את סוג החיבור הקבוע שמוגדר כברירת מחדל.

הדוגמה הבאה מחילה סוג מפרק עגול על קו פוליגוני:

Kotlin



polyline.jointType = JointType.ROUND

Java


polyline.setJointType(JointType.ROUND);

סוג החיבור משפיע על הכיפופים הפנימיים בקו. אם יש קו חוצה כולל מקפים, סוג החיבור רלוונטי גם כאשר קו מפריד מכשיר משותף. סוגי המפרקים לא משפיעים על נקודות, מכיוון שהן תמיד מעגליות.

אותיות רישיות

אפשר לציין סגנון Cap לכל קצה של קו פוליגוני. האפשרויות הן עגולות (ברירת מחדל), ריבוע, עגול או מפת סיביות מותאמת אישית. מגדירים את הסגנון בPolylineOptions.startCap PolylineOptions.endCap, או להשתמש שיטות מתאימות של getter ו-setter.

קטע הקוד הבא מציין מכסה עגולה בתחילת קו פוליגוני.

Kotlin



polyline.startCap = RoundCap()

Java


polyline.setStartCap(new RoundCap());

קטע הקוד הבא מציין מפת סיביות מותאמת אישית עבור מודעת הסיום:

Kotlin



polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)

Java


polyline.setEndCap(
    new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));

כשמשתמשים במפת סיביות מותאמת אישית, צריך לציין רוחב קווים בהתייחסות פיקסלים. ה-API משנה את מפת הסיביות בהתאם. רוחב קו ההפניה הוא רוחב הקווים שבו השתמשת כשעיצבת את תמונת מפת הסיביות של המכסה, הגודל המקורי של התמונה. ברירת המחדל של רוחב קו הרוחב להפניה היא 10. פיקסלים. רמז: כדי לקבוע את רוחב קו ההפניה, צריך לפתוח את התמונה של מפת הסיביות בכתובת שינוי של 100% בכלי לעריכת תמונות, לשרטט את הרוחב הרצוי של קו הקו ביחס לתמונה.

אם משתמשים BitmapDescriptorFactory.fromResource() כדי ליצור את מפת הסיביות, צריך להשתמש במשאב שלא תלוי בדחיסות (nodpi).

פלחים גיאודזיים

ההגדרה הגאודזית חלה רק על קווים פוליגוניים ופוליגונים. לא רלוונטי למעגלים כי הם לא מוגדרים כאוסף של פלחים.

ההגדרה הגאודזית קובעת את האופן שבו מקטעי הקו בין עוקבים הקודקודים של הפוליגון/פוליגון משורטטים. פלחים גיאודזיים הם אלה ללכת במסלול הקצר ביותר לאורך פני השטח של כדור הארץ (ספרה), ולרוב יופיעו כקווים מעוקלים במפה עם היטל Mercator. לא גיאוגרפי קטעים משורטטים כקווים ישרים במפה.

כדי להגדיר את המאפיין הזה באובייקט האפשרות של הצורה, צריך להפעיל *Options.geodesic() כאשר true מציין את הקטעים שיש לצייר עליהם גיאודסיקה ו-false מציינים את הקטעים שיש לשרטט כקווים ישרים. אם לא צוין אחרת, ברירת המחדל היא פלחים לא גיאוגרפיים (false).

לאחר הוספת הצורה למפה, ניתן לגשת להגדרה הגיאודסית באמצעות חיוג אל isGeodesic(), וייתכן שיתבצע שינוי בהתקשרות אל setGeodesic().

אינדקס Z

ה-z-index מציין את סדר הערימה של הצורה הזו, ביחס שכבות-על (צורות אחרות, שכבות-על של קרקע ושכבות-על של משבצות) במפה. שכבת-על עם אינדקס z גבוה מצוירת מעל שכבות-על עם מדדי z נמוכים יותר. שתי שכבות-על עם אותו z-index מצוירות בסדר שרירותי.

שים לב שהסמנים תמיד משורטטים מעל שכבות-על אחרות, ללא קשר z-index של שכבות-העל האחרות.

כדי להגדיר את המאפיין הזה באובייקט האפשרויות של הצורה, שולחים קריאה ל-*Options.zIndex(). אם לא צוין, ערך ברירת המחדל של z-index הוא 0. אחרי הוספת הצורה אל במפה, ניתן לגשת ל-z-index דרך מתקשר אל getZIndex() וייתכן שהוא ישתנה באמצעות חיוג אל setZIndex().

חשיפה

הראות מציינת אם יש לשרטט את הצורה על המפה, כאשר true מציין שצריך לצייר ו-false מציין שלא צריך לצייר. הוא מאפשרת לא להציג צורה במפה באופן זמני. אל באופן סופי להסיר את הצורה מהמפה, קוראים לפונקציה remove() על הצורה הזו.

כדי להגדיר את המאפיין הזה באובייקט האפשרויות של הצורה, צריך להפעיל *Options.visible() אם לא צוין, ברירת המחדל של הרשאות הגישה היא true. לאחר הוספת הצורה למפה, ניתן לגשת אליהם על ידי מתקשר אל isVisible() וייתכן שהוא ישתנה באמצעות חיוג אל setVisible().

שיוך נתונים לצורה

ניתן לאחסן אובייקט נתונים שרירותי עם קו פוליגוני, פוליגון או מעגל באמצעות השיטה setTag() של הצורה, ומאחזרים את האובייקט באמצעות getTag(). לדוגמה, כדי לאחסן נתונים, קוראים לפונקציה Polyline.setTag() אובייקט עם קו פוליגוני, וקוראים לפונקציה Polyline.getTag() מאחזרים את אובייקט הנתונים.

הקוד שבהמשך מגדיר תג שרירותי (A) עבור הקו הפוליגוני שצוין:

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .clickable(true)
        .add(
            LatLng(-35.016, 143.321),
            LatLng(-34.747, 145.592),
            LatLng(-34.364, 147.891),
            LatLng(-33.501, 150.217),
            LatLng(-32.306, 149.248),
            LatLng(-32.491, 147.309)
        )
)
polyline.tag = "A"

Java


Polyline polyline = map.addPolyline((new PolylineOptions())
    .clickable(true)
    .add(new LatLng(-35.016, 143.321),
        new LatLng(-34.747, 145.592),
        new LatLng(-34.364, 147.891),
        new LatLng(-33.501, 150.217),
        new LatLng(-32.306, 149.248),
        new LatLng(-32.491, 147.309)));

polyline.setTag("A");

הנה כמה דוגמאות לתרחישים שבהם כדאי לאחסן ולאחזר נתונים עם צורות:

האפליקציה עשויה לתת סוגים שונים של צורות, וכדאי לטפל בהן אחרת כשהמשתמש לוחץ עליהן.
יכול להיות שאתם מתממשקים עם מערכת שיש לה מזהי רשומות ייחודיים, שבהן הצורות מייצגות רשומות ספציפיות במערכת.
נתוני הצורה עשויים לציין עדיפות לקביעת מדד ה-z עבור .